Same-prompt Codex and Claude Code outputs with generated code links. Credit: original public source links stay attached to every result.
These are the public outputs created from the same prompts, shown as inspectable code results rather than only summaries.
A public GitHub comparison where the same competitive-intelligence app prompts produced separate Claude Code and Codex implementations.
Build a mobile-friendly black-and-white competitive-intelligence dashboard with frontend and backend after applying the shared research prompt and application prompt.
This public repository is useful for branch-level inspection, screenshots, and outbound links. Mirror only short excerpts unless permission or a license is added.
A controlled analysis workflow with a streaming API route, prompt builder, service layer, parser, and focused input/result components.
const analysis = await openaiService.analyzeSector(validation.value!, onProgress);
controller.enqueue(sendSSEEvent(encoder, "data", { payload: analysis }));
controller.enqueue(sendSSEEvent(encoder, "complete", {}));A broader dashboard-style implementation with typed request validation, analysis generation, and a richer decision-support shell.
const parsed = sectorRequestSchema.safeParse(payload);
const analysis = await generateCompetitorAnalysis(parsed.data);
return NextResponse.json(analysis);The same prompt produced different project boundaries. This is the first code-level difference visitors should see before reading individual files.
A public benchmark folder with generated Node.js todo CLI implementations from Claude Code and Codex using the same prompt.
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);
});
});
});