代码框架

THINK -- Requirements and Planning

```bash

Requirements

cf prd generate # AI-guided Socratic PRD creation cf prd generate --template lean # Use a specific template cf prd add <file.md> # Import existing PRD cf prd show # Display current PRD

Required (Anthropic is the default provider)

export ANTHROPIC_API_KEY=sk-ant-...

Think. Build. Prove. Ship.

THINK    What are you building? How should it be broken down?
           cf prd generate         Socratic requirements gathering
           cf prd stress-test      Recursive decomposition, surface ambiguities
           cf tasks generate       Atomic tasks with dependency graphs

BUILD    Delegate to the best coding agent for the job
           cf work start --engine  Claude Code, Codex, OpenCode, Kilocode, or built-in
           CodeFRAME owns: verification gates, self-correction, stall detection

PROVE    Is the output any good?
           cf proof run            9-gate evidence-based quality system
           cf proof capture        Glitch becomes a permanent requirement
           cf proof list           All active proof obligations
           cf proof status         Summary across all gates
           cf proof show <id>      Requirement detail and evidence
           cf proof waive <id>     Waive a requirement with justification

SHIP     Deploy with confidence
           cf pr create            PR with proof report attached
           cf pr merge             Only merges if proof passes

THE CLOSED LOOP
  Glitch in production
    -> cf proof capture
    -> New requirement
    -> Enforced on every future build
    = Quality compounding interest

---

BUILD -- Execution

```bash

BUILD (agent adapters)

• [x] Agent adapter architecture -- delegate to Claude Code, Codex, OpenCode, Kilocode via workspace hooks
• [x] Worktree isolation for parallel agent execution
• [x] Reconciliation layer for multi-agent output
• [x] Replay/debug mode (cf work replay)
• [x] TUI dashboard (cf dashboard)
• [x] Dynamic config reload during batch execution
• [x] Multi-provider LLM -- Anthropic, OpenAI, or any OpenAI-compatible endpoint
• [ ] Engine performance tracking and automatic routing

Quick Start

Step 1 — Install

uv tool install codeframe-ai     # installs the `cf` command globally
cf --help                        # smoke test — should print the command tree

No uv? pipx install codeframe-ai works too, or run without installing via uvx codeframe-ai --help. (The PyPI package is codeframe-ai; the command is cf.)

<details> <summary>Install from source (for contributors)</summary>

git clone https://github.com/frankbria/codeframe.git && cd codeframe
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv && source .venv/bin/activate && uv sync
uv run cf --help

When working from source, prefix the commands below with uv run. </details>

Step 2 — Set your API key

export ANTHROPIC_API_KEY="sk-ant-..."   # get yours at https://console.anthropic.com/

Step 3 — Initialize your project

cf init /path/to/your/project --detect

Step 4 — Think: generate a PRD and tasks

cf prd generate          # AI-guided Socratic requirements discovery
cf tasks generate        # Decompose PRD into atomic tasks with dependencies
cf tasks list            # Review what was generated

Step 5 — Promote one task

cf tasks generate creates tasks in BACKLOG so you can review them before an agent touches your code. Pick one and move it to READY — cf tasks list prints an 8-character ID for each task, and that prefix is all you need:

cf tasks list                            # copy the ID of the task you want
cf tasks set status <task-id> READY      # note: id before status

Start with one. A generated backlog is typically 20+ tasks, and your first run should show you the loop, not build the whole project in one sitting.

Step 6 — Build: hand the task to an agent

cf work start <task-id> --execute

Step 7 — Prove: capture a requirement, then verify it

PROOF9 verifies obligations, and a new workspace has none — so verifying it first would report that nothing was checked and exit 2. That is deliberate: a run that checked nothing is not a pass. Give it something to check.

cf proof capture \
  --title "add() returns the wrong sum for negative numbers" \
  --description "Calculation is wrong: add(-1, -1) returned 0 instead of -2" \
  --where src/calc.py --severity high --source qa

That creates a requirement, picks the gates that would have caught it, and writes a draft test stub per gate under tests/proof/<REQ-ID>/. The stubs are named draft_*.py so pytest does not collect them yet, and each one is a placeholder assert False. Turn them into real tests — drop the draft_ prefix from each filename, and replace the placeholder with an assertion that actually proves the bug is fixed:

```bash ls tests/proof/REQ-0001/ # draft_test_..._unit.py, draft_test_..._contract.py

Configuration

```bash

Multi-provider LLM (optional — override default Anthropic provider)

export CODEFRAME_LLM_PROVIDER=openai # anthropic | openai (OpenAI-compatible) export CODEFRAME_LLM_MODEL=gpt-4o # model name for the chosen provider export OPENAI_API_KEY=sk-... # required when provider=openai export OPENAI_BASE_URL=http://localhost:11434/v1 # for Ollama, vLLM, LM Studio, etc.

Per-workspace: .codeframe/config.yaml supports an `llm:` block for the same options

Optional

export DATABASE_PATH=./codeframe.db # Default: ./.codeframe/state.db export RATE_LIMIT_ENABLED=true # API rate limiting export RATE_LIMIT_DEFAULT=100/minute # Default limit ```

For server configuration, rate limiting options, and API key setup, see docs/PHASE_2_DEVELOPER_GUIDE.md.

CLI Reference

All commands below assume the virtual environment is active (source .venv/bin/activate). If it is not active, prefix every cf command with uv run — e.g., uv run cf init ..

THINK (upstream pipeline)

• [x] cf prd stress-test -- Recursive decomposition that surfaces ambiguities before execution
• [x] Multi-round PRD refinement with domain-specific probes
• [ ] Specification-level dependency analysis