claude code is the strongest agentic coding cli there is - fast, flexible, scriptable, and it lives in your terminal. defract drives that same claude code in a pty, and adds the part the terminal leaves to you: the designer, the reviewer, the qa, the release manager, and a process that holds them together. you already have the engine. this is the team around it.
defract runs on claude code - it doesn't replace it. under the hood, defract launches the real claude cli as a child process in a pty, with full tool access, on your own subscription, local-first. this isn't a wrapper around an api or a competing model. claude code is the engine. the question this page answers isn't "which one" - it's whether you want to drive every step in the terminal yourself, or wrap an opinionated process around the same engine so you don't have to hold the whole build in your head.
raw claude code is one powerful agent at a blinking cursor - you decide every stage, every order, every "is this done." defract decides the shape so you don't have to.
scope → design → architecture → implementation → review → release, with a gate at each. agents do the work between gates; you weigh in at them. trivial tasks skip design and architecture; bigger ones get the full path. the structure lives in the tool instead of in your head and your prompts.
in the terminal you are the reviewer of record - you read the diff, you run the checks, you decide. defract ships that as a stage.
types, lint and tests gate every merge, plus review agents for architecture, security and ux. code only progresses once it's signed off. the reviewer applies small, low-risk fixes inline; larger issues loop back to implementation.
a side-by-side diff viewer, risk-sorted files, and evidence-linked checks that jump to the exact hunk. you review intent and shape on a purpose-built ui per phase, not an 800-line scroll.
a fresh terminal session starts cold. defract carries what it learned, and gives design a place in the pipeline.
defract keeps persistent memory of your codebase, decisions, conventions and past mistakes, and a memory-consolidator agent folds each shipped task back in - so the next one starts sharper. it also runs a gated visual design stage: the designer agent writes single-file html mockups, rendered live, that you approve before they drive implementation. compounding the work, and holding context across parallel agents, are the parts the raw cli leaves to you.
| defract | claude code (raw cli) | |
|---|---|---|
| what it is | an opinionated lifecycle app built on claude code | an agentic coding cli in your terminal |
| relationship | drives the real claude cli in a pty - your engine, wrapped in a process | the engine itself |
| structure | enforced lifecycle: scope → design → architecture → implementation → review → release | free-form - you drive every stage and decide when it's done |
| review & gates | agents review agents (types · lint · tests · architecture · security · ux); merge gated on sign-off | you review the diff and run checks yourself (hooks if you script them) |
| what you review | purpose-built uis per phase - intent and shape | terminal output and raw diffs |
| design | a gated visual design stage in the lifecycle | not built in |
| memory / context | persistent memory of codebase, decisions, conventions, mistakes - consolidated per task, compounds over time | CLAUDE.md + context you manage; sessions start fresh |
| parallel git worktrees | ›yes parity | ›yes (you set them up) |
| engine | your claude code (codex · gemini · opencode in v1) | claude code (native) |
| cost | app in open beta; bring your own claude (pay anthropic directly), local-first | your claude subscription or api |
| interface | desktop app | terminal-first (also vs code, jetbrains, web) |
| platform | macos (windows · linux in v1) | macos · linux · windows |
we'll be straight: raw claude code is powerful, flexible, and scriptable, and for a lot of work it's all you need. it lives in your terminal with no extra app in the loop, its agentic search reads your whole codebase, and it bends to whatever you ask in the moment. if you want to drive every step yourself - your own subagents, your own skills, your own slash-command plugins, your own order of operations - that free-form control is a real strength, and defract trades some of it away. defract gives you structure, gates, and a visual surface; that's a deliberate swap, not a free lunch.
and you keep the raw setup either way: defract's pipeline runs fixed, cache-stable agent prompts, but its build and chat modes read your ~/.claude, your CLAUDE.md and your custom subagents like an ordinary claude code run. defract is for the builder who owns a product end to end and wants the lifecycle and the surface around the engine - not a replacement for the engine. when running the agents stopped being the hard part and keeping a multi-stage build coherent and shipped became it, that's the line defract is built for.
download the open beta. it runs on the same claude code you already use.