Two Coding Agents, One Hard Project: How to Split the Work (Lessons From a 1994 Jeep ECU)

Claude Code and Codex reverse engineered a 1994 Jeep's engine computer over a $3 Arduino. Here is the reusable pattern behind it: three ways to split a hard project between two coding agents, how they hand context to each other, and where a human approves.

Ryan Mitchell

Ryan Mitchell

17 November 2026

Two Coding Agents, One Hard Project: How to Split the Work (Lessons From a 1994 Jeep ECU)

Quick answer: To split a hard project between two coding agents, give each agent a role that produces something the other can check: one explores and writes down what it learned, the other builds against that record, or both attempt the same step and you compare. Keep the shared context in one file both agents read, and put a human approval in front of every action that touches the real world.

A developer’s 1994 Jeep Cherokee has no OBD2 port, the standard diagnostic socket on later cars, and in his words “no scan tool that works on it.” Nothing could read its engine computer (the ECU). He wired a $3 Arduino Nano to the diagnostic plug and handed the job to two coding agents, Claude Code and Codex. The video of that project drew 450 points and more than 230 comments on Hacker News this month.

The useful part for your team is how one hard, unfamiliar project got carried by two different agents and one careful human. This guide turns that into a reusable pattern, and shows where Sharkly fits once the two agents outgrow two terminal tabs.

What the Jeep ECU project shows about two coding agents

Here is what the source says, and nothing more. In the video description, the author writes that over about a week the agents “read the computer live, logged my drives, copied its entire program, and ran their own code inside it.” The chapter list credits Claude with figuring out the wiring and running the fuel pump test, and credits Codex with running code inside the computer. One chapter is titled “The night drive: the tool was wrong.”

The xj-scanner repository that came out of it is the more interesting artifact. Three details stand out:

  1. One shared instruction file. AGENTS.md is the entry point for “any agent working in this repo.” CLAUDE.md is a single line that points back to it, so Claude Code and Codex read the same rules.
  2. Written-down knowledge. The docs/ folder holds the plug pinout, the protocol, and every parameter with its scaling, so the next agent starts from what the last one learned.
  3. Hard stops for a human. The rules say reading is safe, but erasing fault codes, resetting fuel trim, and actuator tests that “switch real hardware” each need the person’s go-ahead first.

The video doesn’t publish a formal division of labor, so treat the split below as a pattern drawn from the outcome, not a transcript of his sessions.

When a hard project needs two coding agents

Use two agents when the work has a high cost of being confidently wrong. Reverse engineering, migrations, unfamiliar protocols, and debugging without docs all fit. A second agent with a different model behind it gives you an independent read, and disagreement between them is a signal you can act on.

Skip the second agent when the task is small and well specified. The Sharkly docs on Crews make the same point about coordination in general: assign small, well-defined work to one Agent, and bring in a team only when someone has to interpret the goal and combine results.

Three ways to split a project between coding agents

Pick one pattern per phase, not per project. Discovery, building, and risky live tests each want a different split.

Pattern Agent A Agent B Use it when
Explorer and builder Investigates, writes findings to a file Builds against those findings The domain is unknown and docs are thin
Two independent attempts Solves the step alone Solves the same step alone A wrong answer is expensive and hard to spot
Builder and reviewer Writes the change Reviews it against the spec and data The change is clear but the risk is high

Explorer and builder: who writes the map?

The explorer’s output is a document, not code. In xj-scanner that’s the docs/ folder: the connector measured cavity by cavity, the protocol, the parameter table. The builder works from that file and never has to rediscover the pinout. If the builder hits a contradiction, it updates the doc, so the map stays the single source of truth.

Two independent attempts: how do you compare them?

Give both agents the same prompt and the same inputs, and don’t let either see the other’s answer. Then compare outputs on data you trust. For a protocol decoder, that means feeding both the same captured log and diffing the decoded values. We cover a fair setup for this in Claude Code vs Codex on the same bug.

Builder and reviewer: what does the reviewer check?

The reviewer checks claims against evidence, not style. “Fuel trim reads +40%” is a claim; the reviewer asks whether the scaling formula is right before anyone acts on it. The xj-scanner rules encode this: “A reading that looks wrong may be a scaling quirk.” Our guide on mixed-model Crews with a separate reviewer goes deeper on pairing a cheaper worker with a stronger reviewer.

How two coding agents hand context to each other

Agents don’t share memory, so the handoff has to live in files and task records. Four pieces carry most of the weight:

  • One instruction file both agents read. AGENTS.md is the open format Codex reads; Claude Code reads CLAUDE.md, and its memory docs describe importing other files. A one-line CLAUDE.md that points to AGENTS.md keeps both on the same rules.
  • A findings doc per domain. Pinouts, protocols, and quirks go in docs/, not in a chat history that disappears.
  • Logs as shared evidence. xj-scanner writes every drive to pc/logs/ as CSV, so either agent can analyze the same run.
  • A handoff note per step. What was tried, what worked, what’s unverified, and the next command.

A handoff note can be this short (illustrative values, not from the Jeep repo):

## Handoff: SCI read of live sensor data
- Done: Nano bridge sketch flashed, DEMO mode passes on the laptop side
- Confirmed: cavities 2 (ground), 3, 4 measured with key ON
- Unverified: fuel trim scaling; reading looks high on idle
- Next: Codex decodes pc/logs/xj_2026-11-03.csv with both scaling formulas
- Needs a human: any actuator test or code erase

For more formats, see our coding-agent handoff templates and the guide to keeping context when switching between coding agents.

Where the human checks the result

Put a person at every step that is hard to undo, and nowhere else. The xj-scanner rules are a clean template:

  1. Before anything physical. “Never let anything be connected to a 12 V cavity.” The person measures every cavity first.
  2. Before any destructive command. Erasing codes also clears learned fuel data, so the agent asks and explains.
  3. Before trusting a diagnosis. “Don’t guess at a diagnosis. Report what the data shows and what it doesn’t.”
  4. After a surprise. The night-drive chapter says the tool was wrong; real-world data is the check no agent can skip.

The same rule holds for a software team. Merges to main, schema migrations, and anything that sends email or spends money get a human gate. Everything else can flow between agents. If review is already your bottleneck, read designing review for parallel agents.

Running a two-agent split in Sharkly

In a terminal, the split lives in your head: which tab runs which agent, and who is waiting on you. Sharkly moves it onto a task.

You connect a Computer, and Sharkly detects the agent tools on it as Runtimes, such as Claude Code and Codex. You create an Agent for each role. Then you build a Crew: a leader Agent plus the explorer, builder, or reviewer Agents, and the People who approve.

Assign the task to the Crew and execution runs leader-first, per the Crews docs. The leader reads the task and Crew instructions, mentions the Agent members it needs, and those members run against the same task and post their results to its chat. The leader combines them. Your role descriptions become Crew instructions: when to involve the reviewer, how to merge two attempts, and when a person decides.

Two details matter for this pattern. Repository work can use a separate git worktree for each run, so two agents attempting the same step don’t overwrite each other (task execution docs). And every run has a state in the task’s execution log, so you can see which agent is queued, running, or done without opening terminals.

Alternatives to a two-agent Crew

You have other options, and some fit better:

  • One agent, two passes. Ask the same agent to build, then to review in a fresh session. Cheaper, but the same model tends to repeat its own blind spots.
  • Two terminals, one shared repo. It works for a weekend project like the Jeep. It gets hard to track once there are several tasks and a teammate. See running Claude Code and Codex together on one codebase.
  • Parallel agents on separate tasks. Useful for throughput, not for checking each other. Watch for two agents editing the same file.

Conclusion

The Jeep project worked because the knowledge lived in files, both agents read the same rules, and a human stood in front of every risky action. Copy those three habits and two coding agents become a check on each other instead of two sources of confident guesses.

Next step: pick one hard task this week, write its AGENTS.md rules and handoff note, and run it as a Crew in Sharkly with a reviewer Agent and a person on the approval.

FAQ

Can Claude Code and Codex work on the same project?

Yes. Both read instruction files in the repo: Codex reads AGENTS.md, and Claude Code reads CLAUDE.md, which can point to AGENTS.md. Give each a separate worktree or a separate step so they don’t edit the same files at once.

How do coding agents share context?

Through files and task records, not memory. Keep rules in AGENTS.md, findings in a docs folder, raw data in logs, and a short handoff note per step.

Where should a human approve agent work?

Before anything hard to undo: hardware actions, destructive commands, merges to main, migrations, and anything that sends messages or spends money. Let the rest flow between agents.

Did Claude Code and Codex reverse engineer the Jeep ECU on their own?

No. The developer did the wiring, the measurements, and the driving, and the repo’s rules require the person’s go-ahead before risky commands. The agents read the computer, logged drives, copied its program, and ran code inside it.

Do you need a platform to run two coding agents?

No. Two terminals and a shared repo work for one project. A platform starts to pay off when several tasks, teammates, and approvals are in flight and you need one record of who did what.

Explore more

GPT-6.2 Codex Guide: How to Use Astra and Sol for Coding

GPT-6.2 Codex Guide: How to Use Astra and Sol for Coding

GPT-6.2 Codex setup: when to pick Astra or Sol, how to switch with /model or config.toml, which reasoning effort to start with, and how to route a team's Codex agents.

18 November 2026

Should AI-Generated Code Be Open Source? What It Means for Teams Shipping With Agents

Should AI-Generated Code Be Open Source? What It Means for Teams Shipping With Agents

A Hacker News post argues all AI-generated code should be open source. Here is the argument, the counter-arguments, where U.S. and UK copyright law stand, and the provenance record every team shipping with coding agents needs regardless of how the debate ends.

17 November 2026

Businesses in ChatGPT: What It Means for Small Teams

Businesses in ChatGPT: What It Means for Small Teams

Businesses in ChatGPT explained for small teams: what Business Hub and Business Agents do, what OpenAI says it costs, and who owns the weekly upkeep.

16 November 2026

Two Coding Agents, One Hard Project: How to Split the Work (Lessons From a 1994 Jeep ECU)