ClawCode

Creative dev tool / AI engineering Swiss Army knife (terminal-native)

Turn idea → memory → plan → code → verify → review → learned experience into one executable, learnable, evolving engineering loop.

English (this page) · 简体中文

Table of contents

• What is ClawCode?
• Product vision
• Value at a glance
• Who it’s for / Get started
• Capability matrix (definition–problem–value–entry)
• Full-stack development loop (diagram)
• Master–slave agent architecture (diagram)
• How ClawCode compares
• Alignment with Claude Code (workflow migration)
• Pro development: slash commands & skills
• Quick start
• Configuration & capability switches
• Tiered onboarding
• High-value scenarios
• Documentation index
• What’s New
• Roadmap
• Contributing
• Security
• License

What is ClawCode?

If you think of an AI coding assistant as “a chat box that writes code,” ClawCode is not in that category.
ClawCode is positioned as a creative dev tool + engineering execution system.

• For individuals: a durable terminal partner that doesn’t only answer “how,” but helps you finish and verify.
• For teams: a governable intelligent workspace with role splits, policy configuration, session continuity, and experience write-back.

Think of it as an AI engineering Swiss Army knife: immediate execution and long-term learning and self-improvement.

Product vision

ClawCode is not “yet another chat assistant”; it is a creative dev tool aimed at real delivery. Core motivations:

• Turn ideas into runnable code quickly
  From “I have an idea” to “implemented and verified,” with less context switching and tool friction.

• Stay vendor- and model-agnostic
  Configurable providers/models and open extension paths reduce lock-in.

• Reuse strong UX patterns instead of reinventing habits
  Learn from mature tools (e.g. Claude Code, Cursor) and preserve familiar workflows where possible.

• Remember usage and improve over time
  Session persistence, experience write-back, and closed-loop learning let the system evolve with tasks and team practice.

• Execute “full-stack” engineering tasks end-to-end
  Beyond one-off codegen: planning, delegation, execution, verification, review, and structured learning.

Full-stack task execution stack (Claw framework + tools + computer use)

“Full-stack” tasks are not a single codegen step—they chain planning, coding, verification, review, environment actions, and learning into one executable path. ClawCode implements three layers:

desktop_* is off by default. Enable explicitly and install optional extras (e.g. pip install -e ".[desktop]" or equivalent). Prefer least privilege and a controlled environment.

That is why ClawCode combines terminal execution + team orchestration + experience evolution in one framework: a long-lived engineering partner—not a short Q&A toy.

Value at a glance

Who it’s for / Get started

Who it’s for

• Developers who live in the terminal and want AI to execute, not only suggest.
• Teams that need multi-role collaboration, governable flows, and reviewable outputs.
• Leads who care about long-term outcomes, not a single answer.

Get started

cd clawcode
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -e ".[dev]"
clawcode

Project highlights — beyond “just writing code”

1) Long-horizon projects: durable memory + continuous context

Sessions and messages persist locally—not a throwaway chat. Split complex work across rounds, keep decisions and history, and support handoff and postmortems.

Why it matters: Fits real long-cycle development, not one-off demos.

2) clawteam: a schedulable virtual R&D team

With /clawteam, the system can orchestrate roles and execution:

• Intelligent role pick and assignment
• Serial/parallel flow planning
• Per-role outputs and final integration
• 10+ professional roles (product, architecture, backend, frontend, QA, SRE, …)

clawteam roles (overview)

Short aliases (e.g. qa, sre, product-manager) map to the clawteam-* roles above—see docs/CLAWTEAM_SLASH_GUIDE.md.
Why it matters: Moves from “one model, one thread” to multi-role collaborative problem solving.

3) clawteam deeploop: convergent closed-loop iteration

/clawteam --deep_loop runs multiple converging rounds—not “one pass and done.”

• Structured contract per round (goals, handoffs, gaps, …)
• Parse DEEP_LOOP_WRITEBACK_JSON and write back automatically when configured
• Tunable convergence thresholds, max iterations, rollback, consistency

Why it matters: Turns “feels done” into metric-driven convergence.

4) Closed-loop learning: Experience / ECAP / TECAP

ClawCode treats experience as a first-class artifact—not only conclusions, but portable structure:

• Experience: an experience function between goals and outcomes; gap drives improvement.
• ECAP (Experience Capsule): individual/task-level capsules.
• TECAP (Team Experience Capsule): team collaboration capsules.
• instinct–experience–skill: reusable path from rules and experience to skills.

Implementation mapping (concept to code)

Closed-loop evolution (implementation view)

flowchart LR
  taskExec[Task execution and tool observations] --> expSignal[Experience signal extraction]
  expSignal --> ecapCreate[ECAP create and structured store]
  ecapCreate --> ecapApply[ECAP retrieve and apply before new work]
  ecapApply --> taskOutcome[Outcome and verification]
  taskOutcome --> feedback[experience_feedback scores]
  feedback --> evolveSkill[instinct_experience_skill evolution]
  evolveSkill --> teamCollab[clawteam collaboration]
  teamCollab --> tecapCreate[TECAP create or upgrade to tecap_v2]
  tecapCreate --> teamApply[team_experience_apply context injection]
  teamApply --> loopGate[deep_loop convergence and write-back]
  loopGate --> expSignal

Why it matters: The system doesn’t only “do it once”—it improves the next run from feedback.

5) Code Awareness: coding perception and trace visibility

In the TUI, Code Awareness helps with:

• Read/write path awareness and behavioral traces
• Clearer context around the working set and file relationships
• Layering and impact scope

Why it matters: Makes what the AI is doing visible and governable—not a black box.

6) Master–slave agents + Plan / Execute

• Master agent: strategy and control
• Sub-agents / tasks: decomposition and execution
• Plan-then-execute for stable progress

Why it matters: Converge on a plan first, then land changes with less churn.

7) Ecosystem alignment (migration-friendly) + extensions

• Aligns with Claude Code / Codex / OpenCode workflow semantics (complementary positioning)
• Reusable plugin and skill systems
• MCP integration
• Optional computer use / desktop (policy- and permission-gated)

Why it matters: Lower migration cost first, then amplify unique capabilities; stay open to your existing toolchain.

Capability matrix (definition–problem–value–entry)

Full-stack development loop (diagram)

flowchart LR
  idea[Idea] --> plan[Plan mode]
  plan --> team[clawteam roles]
  team --> execute[Execute and tools]
  execute --> deeploop[deeploop convergence]
  deeploop --> writeback[DEEP_LOOP_WRITEBACK_JSON write-back]
  writeback --> ecap[ECAP / TECAP store]
  ecap --> evolve[Experience evolution and reuse]
  evolve --> plan

Master–slave agent architecture (diagram)

flowchart TD
  user[User goal] --> master[Master agent]
  master --> planner[Decompose and plan]
  planner --> subA[Sub-agent A]
  planner --> subB[Sub-agent B]
  planner --> subC[Sub-agent C]
  subA --> toolsA[Tools and results]
  subB --> toolsB[Tools and results]
  subC --> toolsC[Tools and results]
  toolsA --> integrate[Master integration]
  toolsB --> integrate
  toolsC --> integrate
  integrate --> verify[Verify and risk]
  verify --> memory[Session and experience store]

How ClawCode compares

Scope note: Capability and architecture comparison only—no “X% faster” claims; based on documented, verifiable behavior.

Alignment with Claude Code (workflow migration)

To lower learning and migration cost, ClawCode offers alignable workflows where it matters.

• If you want polished product UX out of the box, Claude Code has strengths.
• If you want deep terminal execution + team orchestration + learning loops + configurable extensions, ClawCode emphasizes that combination.

ClawCode is not trying to replace every tool. It uses alignment as a migration layer and closed-loop engineering evolution as the core value layer.

Pro development: slash commands & skills

Beyond migration-friendly defaults, ClawCode ships built-in pro workflows: common multi-step flows as /slash commands, with skills to encode team practice.

1) Built-in /slash commands (engineering workflows)

Full list: clawcode/tui/builtin_slash.py. Deep dives: docs/CLAWTEAM_SLASH_GUIDE.md, docs/ARCHITECT_SLASH_GUIDE.md, docs/MULTI_PLAN_SLASH_GUIDE.md.

2) Bundled skills (reusable expertise)

Paths: clawcode/plugin/builtin_plugins/clawcode-skills/skills/.
Suggested flow: frame execution with /clawteam or /multi-plan, then layer domain skills for consistency.

Quick start

Requirements

• Python >=3.12
• At least one configured model provider credential

Install (source / dev)

cd clawcode
python -m venv .venv
# Windows PowerShell
.\.venv\Scripts\Activate.ps1
pip install -e ".[dev]"

Run

clawcode
# or
python -m clawcode

Prompt mode

clawcode -p "Summarize this repository’s architecture in five bullets."

JSON output mode

clawcode -p "Summarize recent changes" -f json

Configuration & capability switches

ClawCode is configuration-driven. Main entry points:

• pyproject.toml (metadata and dependencies)
• clawcode/config/settings.py (runtime settings model)

Typical knobs:

• Provider / model selection
• /clawteam --deep_loop convergence parameters
• Experience / ECAP / TECAP behavior
• Desktop / computer-use and other optional features

Tiered onboarding

~5 minutes (run it)

1. Install and start clawcode
2. Run clawcode -p "..." once
3. In the TUI, try /clawteam <your ask>

~30 minutes (close the loop)

1. Pick a small real task (fix / refactor / tests)
2. Run /clawteam --deep_loop for 2–3 rounds
3. Inspect DEEP_LOOP_WRITEBACK_JSON and write-back results

Team rollout (repeatable)

1. Align model and policy (provider/model)
2. Inventory reusable skills/plugins and minimal conventions
3. Wire feedback into ECAP/TECAP

High-value scenarios

• Greenfield complexity: plan first, execute across converging rounds
• Legacy modernization: multi-role risk ordering and sequencing
• Handoffs: sessions and experience that can be reviewed and migrated
• Long-running work: iterate without losing thread
• Automation: CLI and scriptable batches

Documentation index

What’s New

• clawteam --deep_loop automatic write-back path and manual /clawteam-deeploop-finalize fallback
• Convergence-related settings such as clawteam_deeploop_consistency_min
• Deeploop event aggregation and test coverage improvements
• Documentation for clawteam_deeploop_* and closed-loop behavior

Roadmap

• Richer Code Awareness (read/write traces mapped to architecture layers)
• Team-level experience dashboards (aggregated metrics)
• Slash workflow templates (task type → flow template)
• Stronger computer-use safety policies and extension hooks

Contributing

Contributions welcome. Before opening a PR:

pytest
ruff check .
mypy .

For larger design changes, open an issue first to align scope and goals.

Security

AI tooling may run commands and modify files. Use ClawCode in a controlled environment, review outputs, and apply least privilege to credentials and capability switches.

License

GPL-3.0 license.