Developer Muhammad Zulali says he connected Claude Code and Codex to his 1994 Jeep Cherokee’s engine computer through a $3 Arduino Nano. In his November 10, 2026 video, he describes reading engine data, copying the computer’s program and running custom code. The moment drawing particular attention is his claim that Claude activated the fuel pump for about ten seconds after he approved the action.
The accompanying xj-scanner repository makes this more useful than a disconnected demonstration. It publishes the software, wiring documentation and agent instructions, while identifying the exact vehicle tested and a connector mistake that could expose the electronics to 12 volts.
The public reaction is documented, too. An opened Hacker News discussion showed 413 points and 196 comments. Automotive publication The Autopian said readers had repeatedly sent it the video, showing circulation beyond AI-focused forums.
The practical lesson is specific: once a coding agent can reach an actuator through software, asking it to be careful is a different protection from preventing unsafe commands.
What the $3 Arduino Actually Connects
The repository describes three wires running from the Jeep’s under-hood diagnostic connector to an Arduino Nano, which connects to a laptop over USB. The Nano acts as the bridge between the vehicle interface and laptop software.
The $3 figure refers to the Nano, not the complete setup. The README estimates about $15 for its listed hardware and supplies, including a breadboard, jumper wires, connector terminals and a multimeter. A laptop is also needed.
Zulali built and tested the project on a 1994 Jeep Cherokee XJ with a 4.0-liter engine and engine computer part number 56030117. The repository targets the older Chrysler/Jeep SBEC, OBD1 computer family and says related 1991–1995 units should be similar. That is a compatibility expectation, not evidence of testing across those vehicles.
Its most consequential wiring detail is unusually easy to miss: connector cavity 6 carries 12 volts with the key on and must not be connected to the interface. On the test vehicle, that wire had the same black-and-white coloring as the ground wire. The README therefore requires checking the cavities with a multimeter instead of trusting wire color.
That warning deserves more attention than the board’s price. Cheap components can make experimentation accessible, but they do not reduce the consequences of connecting to the wrong voltage. The repository’s meter-first approach is a useful boundary between following instructions and verifying a physical condition. The README documents both the setup and warning.
How the Published Workflow Fits Together
The project separates the work into several layers:
- Arduino firmware provides the vehicle-to-USB bridge.
- The Python scanner,
pc/xj_scan.py, handles fault codes, live data, logging and actuator tests. - Helper tools summarize logs, inspect parameters and check the computer’s part number.
- Agent instructions and playbooks guide a coding assistant through setup and diagnostic tasks.
The Autopian’s account identifies the older communication protocol as Chrysler SCI. The important mechanism is straightforward: the agent works through local code and a hardware interface that can exchange messages with the engine computer. It is not controlling the Jeep through a model capability that independently understands automotive electronics.
According to Zulali’s account, Claude Code read live data and copied the ECU program, while Codex helped run custom code in the computer’s memory. Those are distinct capabilities. Reading a sensor value, requesting a built-in actuator test and executing a program inside an ECU each grant a different level of influence over the vehicle.
I would evaluate those permissions separately. A successful diagnostic read provides no assurance that an actuator command or a memory-writing operation has appropriate safeguards.
Start With the Simulator, Not the Vehicle
The repository includes a simulated Jeep mode for checking the laptop-side software. From the repository directory, its documented commands can be separated into these steps:
python3 -m venv .venv
.venv/bin/pip install -r pc/requirements.txt
.venv/bin/python pc/xj_scan.py --cli DEMO
These commands create a Python virtual environment, install the project’s dependencies and launch its simulated-vehicle mode. They are reproduced from the published instructions, not commands Zeniteq executed. The DEMO argument matters: this is the laptop-side check, not the hardware-connected scanning command.
For anyone evaluating the project, that is the sensible first boundary. Software installation and simulated readings can be inspected before introducing vehicle wiring or actuator access.
The Reverse Engineering Has an Open-Source Foundation
The repository credits ChryslerScanner by László Dániel for parameter identifiers, scaling formulas, the OBD1 message sequence and fault-code text. It also says the fuel-trim scale was resolved using disassembled SBEC code in the AR1972/jeep_2.5L project. xj-scanner itself is GPLv3-licensed.
Those credits qualify the headline description of agents reverse-engineering a Jeep. The published result combines existing protocol knowledge, earlier reverse engineering, new tooling and Zulali’s physical setup.
A detail in The Autopian’s coverage shows why that foundation matters. Its account says an apparent fuel-trim problem initially pointed the investigation in the wrong direction because a tool’s interpretation was wrong. The repository’s explicit credit for resolving the fuel-trim scale gives that issue technical context.
An ECU value must be decoded with the correct units and scaling before it becomes useful diagnostic evidence. An agent can reason fluently about an incorrectly interpreted number and still reach the wrong conclusion. In my view, publishing the decoding assumptions is one of this project’s most valuable features: it makes the measurement layer inspectable.
What Zulali Says Happened With the Fuel Pump
A passage from Zulali’s video, reproduced in the Hacker News thread, describes Claude suggesting that it could run the fuel pump. Zulali says he approved because he doubted it could actually do so. He then describes the pump continuing to prime the fuel rail for roughly ten seconds before he asked Claude to stop.
That sequence matters. His account includes human approval; it is not evidence that Claude independently decided to activate the pump against an explicit refusal.
It also leaves important engineering questions unanswered. Approval to try an action does not specify its maximum duration, its acceptable operating conditions or how it must stop if communication fails.
The fuel-pump activation and claimed eventual California emissions-test pass remain Zulali’s account. Zeniteq has not independently reproduced the project. The repository documents an interface and its capabilities, but it does not independently verify every event in the video. The cited materials include no response from Anthropic or OpenAI addressing the fuel-pump claim.
The published account also does not establish that this ten-second activation damaged anything. Some Hacker News commenters argued that continuous pump operation can be normal in a return-style fuel system. That discussion should not become an unsupported claim that the Jeep narrowly avoided catastrophe.
The stronger safety concern is the control boundary: what, outside the model’s reasoning, constrained the command?
Why the Discussion Focused on Markdown Instructions
One Hacker News commenter describing work with quadruped robots said their project instructions required explicit permission before hardware operation. Another commenter, trollbridge, replied:
Frequently Asked Questions
3 questions
1Does the Whole Setup Cost $3?
No. That figure refers to the Arduino Nano. The repository estimates about $15 for its listed hardware and supplies, and the setup also requires a laptop.