代码框架

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 tui)
• [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

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   # smoke test — should print the command tree

Step 2 — Set your API key

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

Step 3 — Initialize your project

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

Step 4 — Think: generate a PRD and tasks

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

Step 5 — Build, Prove, and Ship

uv run cf work batch run --all-ready   # Execute all READY tasks (delegates to agent)
uv run cf proof run                    # Run PROOF9 quality gates
uv run cf pr create                    # Open a PR with proof report attached

That is the entire workflow. Everything else is optional.

---

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: in-memory SQLite 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