TL;DR
Table of Contents
- I discovered that Clawed Code turns plain-English prompts into real code, from creating files to building a full website. Clawed Code Overview
- It lives in the terminal, so I never have to switch to an IDE or a browser. Clawed Code Overview
- Permissions protect my machine; I can pre-approve safe commands with an allow list and block sensitive paths with a deny list. Clawed Code Permissions
- The context window holds the conversation; I keep it healthy by running /compact or letting Clawed Code auto-compact when it’s 85-95% full. Clawed Code How It Works
- Checkpoints are automatically created before edits, and /rewind lets me jump back to a prior state. Clawed Code Checkpointing
Why this matters
When I first tried building a product, I kept losing time on boilerplate, slow builds, and permission prompts. Clawed Code solves these pain points by letting me describe what I want in plain English and letting the AI write, test, and deploy code for me. This reduces friction, speeds iteration, and keeps my workflow in the terminal—my natural habitat. I struggled with the confusing interface of other AI tools; Clawed Code’s terminal UI is simple: you type commands or plain prompts, no GUI. Clawed Code Overview
Core concepts
Clawed Code is an AI-driven terminal tool that reads your entire project and reacts to plain-English prompts. Think of it as a cat that sits on your desk and writes code when you say, “Add a login page.” Clawed Code Overview
Plain-English prompts
Instead of memorizing complex command syntax, I write natural language instructions. For example:
clue: create a new React component called Hero
Clawed Code interprets this and creates Hero.jsx for me. Clawed Code Overview
Permission model
Before any big change, Clawed Code asks for approval. If I want to skip these prompts, I add the command to an allow list in ~/.claude/settings.json or a project-level .claude/settings.json. To block dangerous paths, I use a deny list. Clawed Code Permissions
Tools
The AI can read, write, and run bash. I give it a prompt and it uses the right tool automatically. Clawed Code Overview
Context window
Clawed Code keeps the conversation in a context window, usually 200 k tokens. When it’s 85–95% full, it automatically compacts the oldest messages. I can also run /compact to summarize old context and free space. Clawed Code How It Works
Tokens and cost
One token ≈ 3/4 word, 1 000 tokens ≈ 750 words. Costs vary by model: Haiku is cheap (~$1/MT), Sonnet ~ $3/MT, Opus ~ $5/MT. I monitor usage with /cost and /stats. Token Counting | Claude API Pricing
Models
Haiku – fast, cheapest; Sonnet – middle; Opus – most powerful. I switch with –model or /model. Model Config
Checkpoints
Every file edit creates a checkpoint. I can rewind with /rewind or restore a specific checkpoint. Checkpoints persist across sessions and are stored in hidden .claude/checkpoints. Clawed Code Checkpointing
GitHub integration
Clawed Code can talk to GitHub: create branches, commit changes, and even open PRs. I install the GitHub app and add it with claude mcp add –transport stdio github. Clawed Code GitHub Actions
MCP servers
I can plug in other tools—Airtable, Notion, Asana—via MCP servers. The CLI command claude mcp add sets them up. Clawed Code MCP Servers
Subagents and agent teams
For parallel work I can spin up subagents that run in their own contexts, or use agent teams to coordinate multiple sessions. Subagents are lightweight; teams are great for large, multi-stage tasks. Subagents | Agent Teams
Skills and hooks
I can extend Clawed Code with skills (bundled instruction sets) and hooks (scripts that run on events). For example, I add a hook to lint after every write. Clawed Code Skills | Clawed Code Hooks
Headless mode
If I want to run a script or CI job, I use the headless flag -p or –print. Clawed Code then runs non-interactively and outputs structured JSON if I want it. Clawed Code Headless
Ralph loop plugin
The Ralph loop lets me give Clawed Code a prompt and have it iterate until it declares “DONE.” I set a max iteration limit to avoid infinite loops. Ralph Loop
How to apply it
I use Clawed Code in a four-step workflow that keeps me focused, safe, and fast.
- Install and start a session
# On macOS
brew install claude-code
claude
The first launch prompts me to log in. I choose the default model (Haiku) and the terminal UI pops up. Clawed Code Overview
- Initialize the project
claude /init
This creates a CLAUDE.md that records my project conventions—file paths, code style, and how to run tests. I can tweak the file later. Clawed Code How It Works
- Configure permissions I edit ~/.claude/settings.json to add a safe command:
{
"permissions": {
"allow": ["Bash(git diff *)", "Write(*.md)"],
"deny": ["Write(secret.txt)"]
}
}
Now Clawed Code won’t ask me before running a git diff or writing to markdown, but it will block writing to my secrets file. Clawed Code Permissions
- Start building I ask Clawed Code to scaffold a backend:
clue: scaffold a new Express API with authentication
Clawed Code reads my CLAUDE.md, runs the necessary npm scripts, and writes the files. It even creates a GitHub branch if I’ve set up the GitHub integration. Clawed Code Overview | Clawed Code GitHub Actions
Keep the context clean If a session gets long, I run /compact keep api,tests to keep only the API code and tests, dropping earlier brainstorming. The AI summarises the rest. Clawed Code How It Works
Monitor token usage I type /cost to see how many tokens I’ve used and how much it will cost. I compare Haiku vs Sonnet by switching models with /model sonnet and watching the cost line. Token Counting | Claude API Pricing
Use checkpoints After each major change I let Clawed Code create a checkpoint. If I break something, I run /rewind and choose the checkpoint that still passes my tests. Clawed Code Checkpointing
Run in headless mode for CI For a nightly build I add a GitHub Actions workflow that calls:
- name: Run Claude Code
run: claude -p "build and test the project"
Because the command is non-interactive, the job runs fast and I get a JSON report in the logs. Clawed Code Headless
- Iterate with Ralph When I need a new feature that might require many refinements, I start a Ralph loop:
claude /ralph-loop "Add pagination to the product list" --max-iterations 5 --completion-promise "DONE"
The loop stops when the AI says “DONE” or after five passes. Ralph Loop
Pitfalls & edge cases
Permission prompts can slow you down – If you’re in a fast-paced sprint, pre-approve the most common commands in your settings.json. Otherwise, every npm install will pop up a request. Clawed Code Permissions
Context rock – When the context window is 90% full, Clawed Code starts dropping earlier messages. I avoid this by running /compact before hitting the threshold. The automatic compaction triggers at 85–95% capacity, so I usually compact at 80% to be safe. Clawed Code How It Works
Token cost surprises – Switching from Haiku to Opus can triple my bill. I keep an eye on /cost and only use the heavier models for reasoning or when I need more nuance. Token Counting | Claude API Pricing
Too many subagents – Each subagent consumes its own context, so many of them can quickly exhaust the 200 k token window. I limit subagents to a handful and let them finish before launching a new one. Subagents
Infinite loops in Ralph – If I forget to set a completion promise or max iterations, the loop could run forever. I always add –max-iterations 10 and a clear completion token. Ralph Loop
Checkpoint clutter – Automatic checkpoints pile up. I clean them with /rewind or prune old ones with a simple shell script that deletes checkpoints older than a week. Clawed Code Checkpointing
MCP server overload – Connecting too many MCP servers can cause latency. I keep a minimal set of servers relevant to my workflow and enable them only in the current project’s .claude/settings.json. Clawed Code MCP Servers
Quick FAQ
Q1: How does Clawed Code decide which tool to use? A1: It matches the prompt to a tool pattern. If you say “list files”, it uses read; if you say “run tests”, it picks bash. The tool choice is based on the prompt and the current context. Clawed Code Overview
Q2: What is the cost per token for each model? A2: Haiku ≈ $1/MT for input, $5/MT for output; Sonnet ≈ $3/MT; Opus ≈ $5/MT. The exact price depends on your plan and region. Claude API Pricing
Q3: Where are checkpoints stored? A3: Checkpoints live in the hidden .claude/checkpoints directory, one file per prompt that changed a file. They’re part of the project and can be committed or cleaned up. Clawed Code Checkpointing
Q4: Can subagents share context with the main agent? A4: Subagents run in isolated contexts; they can send messages back to the main agent, but they don’t automatically share context beyond the task list. Subagents
Q5: What limits exist on the number of subagents or agent teams? A5: The docs don’t enforce hard limits, but each consumes its own 200 k token window, so practical limits are set by available tokens and your system resources. Subagents | Agent Teams
Q6: How does the Ralph loop plugin decide when to stop? A6: It continues until the AI outputs the specified –completion-promise string (e.g., “DONE”) or the max-iterations cap is reached. Ralph Loop
Q7: Are there safeguards against infinite loops in headless mode? A7: Headless runs are non-interactive; you control iteration limits in your script or by passing –max-iterations. If you forget, the job can hang, so always set a timeout in CI. Clawed Code Headless
Conclusion
Clawed Code turns my plain-English ideas into production-ready code while keeping me in the terminal I love. By configuring permissions, using checkpoints, and monitoring tokens, I can work faster without sacrificing safety or cost. If you’re a founder who wants to ship features quickly without writing endless boilerplate, give Clawed Code a try. Start with a small project, experiment with the slash commands, and watch your development cycle shrink.
