A public benchmark folder with generated Node.js todo CLI implementations from Claude Code and Codex using the same prompt.
Codex produced a modular CLI/store split with injectable file paths; Claude Code Sonnet produced a smaller single-file implementation; Claude Code Haiku used a class-based store.
The same CLI prompt left room for different design choices around persistence, state ownership, and testability.
This source is useful because visitors can inspect complete generated projects, not only screenshots or summaries.
Each panel shows the generated output for the same prompt, links to the original code, and keeps source credit visible.
Build a Node.js CLI todo app with add, list, complete, and delete commands. Data should persist to a JSON file. Initialize git, write tests, and commit your work.
Licensed source can be mirrored in benchmark pages with attribution and links back to the original generated projects.
A modular CLI and store split. The command runner can resolve the todo file through environment or working-directory context, which makes tests easier to isolate.
function resolveTodoFile(cwd) {
return process.env.TODO_FILE || path.join(cwd, "todos.json");
}A compact implementation centered on one todo module, with persistence stored beside the generated script and a direct test file.
const TODO_FILE = path.join(__dirname, "todos.json");
function loadTodos() {
if (!fs.existsSync(TODO_FILE)) return [];
}A class-based store shape that wraps load/save behavior and separates CLI parsing from the persistence object.
class TodoStore {
constructor() {
this.todos = this.loadTodos();
}
}The same prompt produced different project boundaries. This is the first code-level difference visitors should see before reading individual files.
These panels mirror licensed generated code snippets and explain the coding choices made for the same prompt.
Codex isolates JSON persistence behind an explicit file path, while Claude Code Sonnet keeps persistence in a single todo module beside the generated script.
const fs = require('node:fs');
function loadTodos(filePath) {
if (!fs.existsSync(filePath)) {
return [];
}
const raw = fs.readFileSync(filePath, 'utf8').trim();
if (!raw) {
return [];
}
let todos;
try {
todos = JSON.parse(raw);
} catch (error) {
throw new Error(`Failed to parse todo data from ${filePath}.`);
}
if (!Array.isArray(todos)) {
throw new Error(`Todo data at ${filePath} is invalid.`);
}
return todos;
}const fs = require('fs');
const path = require('path');
const TODO_FILE = path.join(__dirname, 'todos.json');
function loadTodos() {
try {
const data = fs.readFileSync(TODO_FILE, 'utf8');
return JSON.parse(data);
} catch (error) {
return [];
}
}
function saveTodos(todos) {
fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
}Codex makes command execution callable with injected IO and working directory context. The Sonnet output keeps the command surface closer to the generated script.
const path = require('node:path');
const { addTodo, listTodos, completeTodo, deleteTodo } = require('./todoStore');
function resolveTodoFile(cwd) {
return process.env.TODO_FILE || path.join(cwd, 'todos.json');
}
function run(argv, io = { stdout: process.stdout, stderr: process.stderr }, cwd = process.cwd()) {
const [command, ...args] = argv;
const filePath = resolveTodoFile(cwd);
if (!command) {
printHelp(io.stderr);
return 1;
}
if (command === 'add') {
const text = args.join(' ').trim();
if (!text) {
io.stderr.write('Error: todo text is required.\n');
printHelp(io.stderr);
return 1;
}
const todo = addTodo(filePath, text);
io.stdout.write(`Added todo ${todo.id}.\n`);
return 0;
}
}function addTodo(task) {
const todos = loadTodos();
const newTodo = {
id: todos.length > 0 ? Math.max(...todos.map(t => t.id)) + 1 : 1,
task,
completed: false
};
todos.push(newTodo);
saveTodos(todos);
return newTodo;
}
function completeTodo(id) {
const todos = loadTodos();
const todo = todos.find(t => t.id === id);
if (!todo) {
return null;
}
todo.completed = true;
saveTodos(todos);
return todo;
}Codex tests the installed CLI behavior through subprocess calls and temporary data files. Claude Code Sonnet tests the todo module directly.
const { spawnSync } = require('node:child_process');
const binPath = path.resolve(__dirname, '..', 'bin', 'todo.js');
function runCli(args, cwd, todoFileName = 'todos.json') {
return spawnSync(process.execPath, [binPath, ...args], {
cwd,
env: {
...process.env,
TODO_FILE: path.join(cwd, todoFileName)
},
encoding: 'utf8'
});
}
test('add and list todos', () => {
const cwd = makeTempDir();
const add = runCli(['add', 'Buy milk'], cwd);
assert.equal(add.status, 0);
assert.match(add.stdout, /Added todo 1\./);
});const { addTodo, listTodos, completeTodo, deleteTodo, loadTodos, saveTodos } = require('./todo');
describe('Todo App', () => {
beforeEach(() => {
if (fs.existsSync(TEST_TODO_FILE)) {
fs.unlinkSync(TEST_TODO_FILE);
}
});
describe('addTodo', () => {
test('should add a new todo', () => {
const todo = addTodo('Test task');
expect(todo.id).toBe(1);
expect(todo.task).toBe('Test task');
expect(todo.completed).toBe(false);
});
});
});Generated Node.js CLI todo app benchmark with JSON persistence, tests, and public source folders for each agent run.
Build a Node.js CLI todo app with add, list, complete, and delete commands. Data should persist to a JSON file. Initialize git, write tests, and commit your work.
Original work: Agent-Field/SWE-AF.
AgentScope is not the original creator of this benchmark. This page credits the source project and links visitors to the public generated folders and raw code.
This result set is useful because it shows how a small prompt still leaves important engineering choices open.
Codex exposes a test-friendly boundary around file storage. Claude Code Sonnet is simpler and easier to read in one file. Claude Code Haiku adds an object-oriented store. Those choices are not just style; they affect test setup, error handling, and how easily a reviewer can reason about state.