Dojo vs. Claude Code: David vs. Goliath on the Same Model

⛩️ Dojo vs. Claude Code ✴️

⛩️ David vs. Goliath ✴️

✴️ Claude Code is a serious tool with serious backing.

⛩️ Dojo is a complete AI Workspace, built by a small, self-funded team.

🎯 Two strong harnesses. One shared brain. Same model (Opus 5.5). Eleven tasks. Every byte logged.

⚖️ Moderator: Meta's Muse Spark 1.3, a neutral third model. It prepped the fixtures, verified every result on disk, and graded fixes against a sealed answer key.

When people compare AI coding tools, they usually end up comparing models. We wanted to measure something else: the harness, meaning the layer between you and the model that decides what context to send, which tools to call, how to batch work, and how to handle images and files. Because both sides ran the same model, every difference below comes from the harness. We're publishing every table, including the rounds Dojo didn't win.

At a glance

✴️ Claude Code

• ✅ Faster on the clock in the build and multi-lookup tasks.
• ✅ Terser answers on many tasks.
• ✅ Same correctness.
• ✅ Caught both critical security vulnerabilities.
• ✅ Perfect scope discipline.
• ✅ No hallucinations.
• ✅ Zero errors across all 11 tasks.

⛩️ Dojo Workspace

• ✅ Same correctness, zero errors.
• ✅ ~39% less input and ~43% less payload across the suite.
• ✅ ~21% less total active time, and fewer API calls.
• ✅ Warmer prompt cache.
• ✅ Half the image bytes on the wire.
• ✅ Knows when the job is already done.
• ✅ Its edge comes from architecture, not the model.

How we kept it fair

• Same model on both sides. Opus 5.5, confirmed on the wire.
• Every request logged. Each harness went through its own local mitmproxy, so we counted real tokens, bytes, calls, and latency rather than trusting self-reports.
• Isolated projects. Each harness opened its own copy of a small Python CLI with injected bugs. No shared folders, no parent config files, and git history stripped so nobody could peek at a diff.
• Identical prompts. The same task text was pasted into both.
• Results checked on disk. "Tests pass" wasn't enough. We re-ran commands, recounted outputs, and graded fixes against a sealed answer key.

We threw out our first attempt: in that pilot, Dojo was accidentally running with extra context from a larger repo, so the setups weren't equal. We rebuilt the fixtures and re-ran everything, then restarted once more after one lane wrote into the other lane's folder. The numbers below are from the clean run.

Key: ✴️ = Claude Code won that row · ⛩️ = Dojo won that row · ⚪ = did not win · 🤝 = tie.

The headline numbers (all 11 tasks combined)

Dojo also wrote slightly fewer output tokens overall, so it didn't get leaner by writing less. It got leaner by sending less context, batching work, and keeping its prompt cache warm.

Scoreboard

All eleven tasks, in full

Task 1: Bug hunt (one obvious bug, one subtle)

Prompt: "There are two bugs in this project — one obvious, one subtle. Find them and fix them. Verify your fixes by running the tests."

Correctness was identical: both fixed the obvious bug and a bonus crash, and both missed the subtle injection-guard bug. Dojo took most efficiency rows.

Task 2: Codebase comprehension (diagram + biggest risk)

Prompt: "Give me a diagram of how a command flows from the CLI entry point to execution. Then tell me the single biggest risk you see and how you'd fix it."

Both named the same real risk (dev commands running against the current folder instead of the project root) and proposed the same fix. Dojo rendered an actual flowchart.

Task 3: Build from scratch (new wordcount command + test)

Prompt: "Add a new command called wordcount that prints lines, words, and characters of a file. Follow the existing patterns. Write a test and run it."

The closest task of the run. Claude Code was faster on the clock; Dojo was leaner on bytes and cache. Both commands worked correctly.

Task 4: Multi-lookup efficiency (three independent lookups)

Prompt: "Count the Python files, find the largest Python file by line count, and list every command this CLI exposes. Do the independent lookups efficiently."

Claude Code won this one on rows, finishing about a second faster. Dojo ran the lookups concurrently in two calls and used half the payload. Both answers were fully accurate.

Task 5: Refactor without changing behavior

Prompt: "Refactor proj stats for readability without changing any of its behavior or output. Run the tests before and after."

We didn't trust green tests here. We re-ran the command on each tree and independently recounted files and folders: both preserved behavior exactly. Dojo did it about 12 seconds faster with a third less payload.

Task 6: Edge-case robustness (missing file)

Prompt: "Run wordcount against a file that doesn't exist. If it crashes, make it fail gracefully with a clear error and a non-zero exit code. Add a test."

Same correct result on both sides. Dojo recognized the command already handled the case, added the test, and stopped: 2 calls and 6 seconds versus 5 calls and 29 seconds.

Task 7: Documentation accuracy (README from real code)

Prompt: "Write a Commands section for the README documenting every command this CLI actually exposes. Do not invent any."

Both READMEs were checked against the live help output: complete, and nothing invented. Dojo finished about 10 seconds faster.

Task 8: Vague bug report (no location given)

Prompt: "A user says proj size reports the wrong size and counts things it shouldn't. Investigate, and if it's a real bug, fix it with a test."

The complaint was real: the command used du, which counts .git, virtual environments, and caches. Both replaced it with the same filtered walk. Dojo needed 4 calls instead of 7 and less than half the input.

Task 9: Instruction adherence (one edit, nothing else)

Prompt: "In stats.py only, add one comment above the function that counts directories. Don't change code, don't touch other files, don't run anything."

Both stayed perfectly in scope. The margins here are a few seconds, so we call it a tie with a soft Dojo lean.

Task 10: Security review

Prompt: "Do a quick security review of commands/utils/subprocess.py. If you find a real issue, explain it and fix it with a test."

The bug both missed in Task 1 was caught by both here, along with a critical shell=True hole. How you frame the task matters: "find bugs" missed it, "security review" found it immediately.

Task 11: Image description (vision payload)

Prompt: "What is in this image? Describe it, and tell me how many people are in it." Same ~117 KB JPEG given to both.

The clearest harness-only result. Dojo optimizes images before they leave your machine, so it sent about half the image bytes, which added up to roughly 3× less payload and 2.7× less input. Claude Code finished the turn faster with a shorter answer. (People-count accuracy wasn't recoverable from the proxy log, so it isn't scored.)

Caveats

• One take per task so far. One run is an anecdote. We're running three takes per task and will publish the averages, including any losses.
• Run-to-run variance is real. In a discarded earlier run, Dojo caught the subtle bug in Task 1. In this run, neither did.
• This measures efficiency and correctness, not everything. Pricing, UX, and ecosystem aren't covered.

The takeaway

With the same model, the same repo, and the same prompts, both harnesses produced correct work. Dojo got there with fewer calls, fewer bytes, and less time on most tasks, and its image handling roughly halved what went over the wire. The model sets the ceiling; the harness decides how efficiently you reach it.

⛩️ Dojo is leaner overall. ✴️ Claude Code wins some quick rounds.

Pick your trade-off.

Next, we'll run the same suite against Codex and Gemini CLI using the same method.

Download

• ⛩️ Dojo Workspace: heydojo.ai
• ✴️ Claude Code: claude.com/product/claude-code

✍️ Written by Dojo · Published by Val Neekman