Benchmarks CLI agents (Claude Code, Codex CLI, Goose CLI and Aider) on Exercism TypeScript programming exercises https://github.com/exercism/typescript/tree/main/exercises/practice

cli-agents-benchmark.ts

#!/usr/bin/env bun

import { spawn } from "bun";
import { join } from "path";
import { readdir } from "fs/promises";

const CLAUDE_CODE_CONTAINER = "cli-agents-benchmark";

const EXERCISM_PRACTICE_PATH = "exercism/typescript/exercises/practice";
const SYSTEM_PROMPT = "'Solve this TypeScript exercise. Read the test file to understand requirements and implement the solution.'";

interface AgentResult {
    exercise: string;
    success: boolean;
    error?: string;
    duration: number;
    output?: string;
}

interface TestResult {
    exercise: string;
    agentSuccess: boolean;
    testSuccess: boolean;
    overallSuccess: boolean;
    agentError?: string;
    testError?: string;
    agentDuration: number;
    testDuration: number;
    totalDuration: number;
}

interface BenchmarkConfig {
    testCommand: string;
    agent: string;
    model: string;
    provider: string;
    verbose: boolean;
}

async function getPracticeExercises(): Promise<string[]> {
    const practiceDir = join(process.cwd(), EXERCISM_PRACTICE_PATH);
    const entries = await readdir(practiceDir, { withFileTypes: true });
    return entries
        .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
        .map(entry => entry.name)
        .sort();
}


async function getTestFiles(exercisePath: string): Promise<string[]> {
    try {
        const exerciseDir = join(process.cwd(), exercisePath);
        const entries = await readdir(exerciseDir);
        return entries.filter(file => file.endsWith('.test.ts'));
    } catch (error) {
        console.warn(`Warning: Could not read test files from ${exercisePath}`);
        return [];
    }
}

function buildTestCommand(config: BenchmarkConfig): string {
    return config.testCommand;
}

function buildAgentCommand(config: BenchmarkConfig, exercisePath: string): string[] {
    const { agent, model, provider } = config;
    const baseArgs = ["docker", "run", "--rm", "-i"];
    
    if (agent === 'claude') {
        return [
            ...baseArgs,
            "-e", "ANTHROPIC_API_KEY",
            "-v", `${join(process.cwd(), exercisePath)}:/workspace`,
            "-w", "/workspace",
            CLAUDE_CODE_CONTAINER,
            "sh", "-c",
            `claude --dangerously-skip-permissions --model ${model} -p .docs/instructions.md --system-prompt "${SYSTEM_PROMPT}"`
        ];
    } else if (agent === 'goose') {
        return [
            ...baseArgs,
            "-e", `GOOSE_MODEL=${model}`,
            "-e", "OPENAI_API_KEY",
            "-e", "ANTHROPIC_API_KEY",
            "-e", "GOOGLE_API_KEY",
            "-e", `GOOSE_PROVIDER=${provider}`,
            "-e", "GOOSE_DISABLE_KEYRING=1",
            "-v", `${join(process.cwd(), exercisePath)}:/workspace`,
            "-w", "/workspace",
            CLAUDE_CODE_CONTAINER,
            "sh", "-c",
            `goose run --with-builtin "developer" -i .docs/instructions.md --system "${SYSTEM_PROMPT}"`
        ];
    } else if (agent === 'aider') {
        return [
            ...baseArgs,
            "-e", "OPENAI_API_KEY",
            "-e", "ANTHROPIC_API_KEY",
            "-e", "GOOGLE_API_KEY",
            "-v", `${join(process.cwd(), exercisePath)}:/workspace`,
            "-w", "/workspace",
            CLAUDE_CODE_CONTAINER,
            "sh", "-c",
            `aider --yes-always --no-auto-commits --message "${SYSTEM_PROMPT} $(cat .docs/instructions.md)" --file *.ts --read *.test.ts`
        ];
    } else if (agent === 'codex') {
        return [
            ...baseArgs,
            "-e", "OPENAI_API_KEY",
            "-v", `${join(process.cwd(), exercisePath)}:/workspace`,
            "-w", "/workspace",
            CLAUDE_CODE_CONTAINER,
            "sh", "-c",
            `codex exec --full-auto --skip-git-repo-check -m ${model} "$(cat .docs/instructions.md)"`
        ];
    } else {
        throw new Error(`Unknown agent: ${agent}`);
    }
}

async function runAgentPhase(config: BenchmarkConfig, exercise: string, exercisePath: string): Promise<AgentResult> {
    const startTime = Date.now();
    
    try {
        const agentArgs = buildAgentCommand(config, exercisePath);
        
        // Add test files as read-only mounts
        const testFiles = await getTestFiles(exercisePath);
        const mountIndex = agentArgs.findIndex(arg => arg === CLAUDE_CODE_CONTAINER);
        
        testFiles.forEach(testFile => {
            agentArgs.splice(mountIndex, 0, "-v", `${join(process.cwd(), exercisePath, testFile)}:/workspace/${testFile}:ro`);
        });
        
        
        if (config.verbose) {
            console.log(`🤖 Agent command: ${agentArgs.join(" ")}`);
        }
        
        const proc = spawn(agentArgs);
        await proc.exited;
        
        const duration = Date.now() - startTime;
        const stdout = await new Response(proc.stdout).text();
        const stderr = await new Response(proc.stderr).text();
        
        if (proc.exitCode === 0) {
            console.log(`🤖 ${exercise} - Agent Success (${duration}ms)`);
            return { exercise, success: true, duration, output: stdout };
        } else {
            console.log(`🤖 ${exercise} - Agent Failed (${duration}ms)`);
            if (config.verbose) {
                console.log(`  Agent STDOUT: ${stdout.slice(0, 500)}...`);
                console.log(`  Agent STDERR: ${stderr.slice(0, 500)}...`);
            }
            return { exercise, success: false, error: `STDOUT: ${stdout}\nSTDERR: ${stderr}`, duration, output: stdout };
        }
    } catch (error) {
        const duration = Date.now() - startTime;
        const errorMsg = error instanceof Error ? error.message : String(error);
        console.log(`🤖 ${exercise} - Agent Error (${duration}ms): ${errorMsg}`);
        return { exercise, success: false, error: errorMsg, duration };
    }
}

async function resetExercise(exercisePath: string, verbose: boolean = false): Promise<void> {
    try {
        if (verbose) {
            console.log(`🔄 Resetting exercise: ${exercisePath}`);
        }
        
        const fullExercisePath = join(process.cwd(), exercisePath);
        const resetArgs = ["git", "-C", fullExercisePath, "checkout", "HEAD", "--", "."];
        const proc = spawn(resetArgs);
        await proc.exited;

        if (proc.exitCode !== 0) {
            const stderr = await new Response(proc.stderr).text();
            console.warn(`Warning: Failed to reset ${exercisePath}: ${stderr}`);
        } else if (verbose) {
            console.log(`✅ Successfully reset ${exercisePath}`);
        }
    } catch (error) {
        const errorMsg = error instanceof Error ? error.message : String(error);
        console.warn(`Warning: Git reset failed for ${exercisePath}: ${errorMsg}`);
    }
}

async function runTestPhase(config: BenchmarkConfig, exercise: string, exercisePath: string): Promise<AgentResult> {
    const startTime = Date.now();
    
    try {
        const testCommand = buildTestCommand(config);
        let testArgs: string[];
        
        testArgs = [
            "docker", "run", "--rm", "-i",
            "-v", `${join(process.cwd(), exercisePath)}:/workspace`,
            "-w", "/workspace",
            CLAUDE_CODE_CONTAINER,
            "sh", "-c", testCommand
        ];
        
        if (config.verbose) {
            console.log(`🧪 Test command: ${testArgs.join(" ")}`);
        }
        
        const proc = spawn(testArgs);
        await proc.exited;
        
        const duration = Date.now() - startTime;
        const stdout = await new Response(proc.stdout).text();
        const stderr = await new Response(proc.stderr).text();
        
        if (proc.exitCode === 0) {
            console.log(`🧪 ${exercise} - Test Success (${duration}ms)`);
            return { exercise, success: true, duration, output: stdout };
        } else {
            console.log(`🧪 ${exercise} - Test Failed (${duration}ms)`);
            if (config.verbose) {
                console.log(`  Test STDOUT: ${stdout.slice(0, 500)}...`);
                console.log(`  Test STDERR: ${stderr.slice(0, 500)}...`);
            }
            return { exercise, success: false, error: `STDOUT: ${stdout}\nSTDERR: ${stderr}`, duration, output: stdout };
        }
    } catch (error) {
        const duration = Date.now() - startTime;
        const errorMsg = error instanceof Error ? error.message : String(error);
        console.log(`🧪 ${exercise} - Test Error (${duration}ms): ${errorMsg}`);
        return { exercise, success: false, error: errorMsg, duration };
    }
}

async function runExercise(config: BenchmarkConfig, exercise: string): Promise<TestResult> {
    const startTime = Date.now();
    const exercisePath = join(EXERCISM_PRACTICE_PATH, exercise);
    
    console.log(`🧪 Starting ${exercise}... (Docker)`);
    
    // Phase 0: Reset exercise to clean state
    await resetExercise(exercisePath, config.verbose);
    
    // Phase 1: Run AI Agent
    const agentResult = await runAgentPhase(config, exercise, exercisePath);
    
    // Phase 2: Run Tests (always run, even if agent failed)
    const testResult = await runTestPhase(config, exercise, exercisePath);
    
    const totalDuration = Date.now() - startTime;
    const overallSuccess = agentResult.success && testResult.success;
    
    if (overallSuccess) {
        console.log(`✅ ${exercise} - Overall Success (${totalDuration}ms)`);
    } else {
        console.log(`❌ ${exercise} - Overall Failed (${totalDuration}ms)`);
        if (!agentResult.success) console.log(`  🤖 Agent failed: ${agentResult.error?.slice(0, 200)}...`);
        if (!testResult.success) console.log(`  🧪 Test failed: ${testResult.error?.slice(0, 200)}...`);
    }
    
    return {
        exercise,
        agentSuccess: agentResult.success,
        testSuccess: testResult.success,
        overallSuccess,
        agentError: agentResult.error,
        testError: testResult.error,
        agentDuration: agentResult.duration,
        testDuration: testResult.duration,
        totalDuration
    };
}

async function runBenchmark(): Promise<void> {
    
    const modelIndex = process.argv.indexOf('--model');
    const model = modelIndex !== -1 && modelIndex + 1 < process.argv.length 
        ? process.argv[modelIndex + 1] 
        : 'sonnet';
    
    const agentIndex = process.argv.indexOf('--agent');
    const agent = agentIndex !== -1 && agentIndex + 1 < process.argv.length 
        ? process.argv[agentIndex + 1] 
        : 'claude';

    const providerIndex = process.argv.indexOf('--provider');
    const provider = providerIndex !== -1 && providerIndex + 1 < process.argv.length 
        ? process.argv[providerIndex + 1] 
        : 'openai';

    const verbose = process.argv.includes('--verbose');

    const exerciseIndex = process.argv.indexOf('--exercise');
    let specificExercise = exerciseIndex !== -1 && exerciseIndex + 1 < process.argv.length 
        ? process.argv[exerciseIndex + 1] 
        : null;
    
    let exerciseCount: number | null = null;
    
    if (specificExercise && /^\d+$/.test(specificExercise)) {
        exerciseCount = parseInt(specificExercise, 10);
        specificExercise = null;
    }
    else if (specificExercise && specificExercise.includes('/')) {
        specificExercise = specificExercise.split('/').pop() || null;
    }

    const listExercises = process.argv.includes('--list');
    
    const allExercises = await getPracticeExercises();
    
    if (listExercises) {
        console.log("📋 Available Exercism problems:");
        allExercises.forEach((exercise, index) => {
            console.log(`  ${(index + 1).toString().padStart(3)}: ${exercise}`);
        });
        return;
    }
    
    console.log("🚀 Starting Exercism TypeScript benchmark");
    console.log(`📋 Solving TypeScript problems with ${agent} agent (Docker mode, ${model} model)\n`);
    
    let exercises: string[];
    if (specificExercise) {
        if (!allExercises.includes(specificExercise)) {
            console.error(`❌ Specified problem '${specificExercise}' not found`);
            console.log("Use --list option to see available problems");
            return;
        }
        exercises = [specificExercise];
        console.log(`🎯 Specified problem: ${specificExercise}\n`);
    } else if (exerciseCount) {
        const count = Math.min(exerciseCount, allExercises.length);
        exercises = allExercises.slice(0, count);
        console.log(`🔢 Number of problems: ${count} (out of ${allExercises.length})\n`);
    } else {
        exercises = allExercises.slice(0, 1);
        console.log(`📊 Found problems: ${allExercises.length} (testing only the first one)\n`);
    }
    
    const results: TestResult[] = [];
    
    const config: BenchmarkConfig = {
        testCommand: 'yarn && yarn test',
        agent,
        model, 
        provider,
        verbose
    };
    
    for (const exercise of exercises) {
        const result = await runExercise(config, exercise);
        results.push(result);
        await new Promise(resolve => setTimeout(resolve, 1000));
    }
    
    const successCount = results.filter(r => r.overallSuccess).length;
    const totalCount = results.length;
    const successRate = (successCount / totalCount) * 100;
    const avgDuration = results.reduce((sum, r) => sum + r.totalDuration, 0) / results.length;
    const agentSuccessCount = results.filter(r => r.agentSuccess).length;
    const testSuccessCount = results.filter(r => r.testSuccess).length;
    
    console.log("\n" + "=".repeat(50));
    console.log("📈 Benchmark Results");
    console.log("=".repeat(50));
    console.log(`🎯 Success Rate: ${successRate.toFixed(1)}% (${successCount}/${totalCount})`);
    console.log(`⏱️  Average Duration: ${avgDuration.toFixed(0)}ms`);
    console.log(`✅ Overall Success: ${successCount}`);
    console.log(`🤖 Agent Success: ${agentSuccessCount}`);
    console.log(`🧪 Test Success: ${testSuccessCount}`);
    console.log(`❌ Failed: ${totalCount - successCount}`);
    
    console.log("\n📝 Detailed Results:");
    results.forEach(result => {
        const overallStatus = result.overallSuccess ? "✅" : "❌";
        const agentStatus = result.agentSuccess ? "🤖" : "❌";
        const testStatus = result.testSuccess ? "🧪" : "❌";
        const duration = `${result.totalDuration}ms`;
        console.log(`  ${overallStatus} ${result.exercise.padEnd(25)} ${duration} (${agentStatus}${testStatus})`);
    });
    
    if (results.some(r => !r.overallSuccess)) {
        console.log("\n🔍 Errors for failed problems:");
        results.filter(r => !r.overallSuccess).forEach(result => {
            console.log(`  ❌ ${result.exercise}:`);
            if (result.agentError) {
                console.log(`     🤖 Agent: ${result.agentError.slice(0, 500)}${result.agentError.length > 500 ? '...' : ''}`);
            }
            if (result.testError) {
                console.log(`     🧪 Test: ${result.testError.slice(0, 500)}${result.testError.length > 500 ? '...' : ''}`);
            }
        });
    }
}

if (import.meta.main) {
    runBenchmark().catch(console.error);
}

Dockerfile

FROM node:22

ARG TZ
ENV TZ="$TZ"

# Install basic development tools and iptables/ipset
RUN apt update && apt install -y less \
  git \
  procps \
  sudo \
  fzf \
  zsh \
  man-db \
  unzip \
  gnupg2 \
  gh \
  iptables \
  ipset \
  iproute2 \
  dnsutils \
  aggregate \
  ripgrep \
  jq

# Ensure default node user has access to /usr/local/share
RUN mkdir -p /usr/local/share/npm-global && \
  chown -R node:node /usr/local/share

ARG USERNAME=node

WORKDIR /workspace
RUN mkdir -p /workspace && \
  chown -R node:node /workspace

# Enable corepack for yarn version management (as root)
ENV COREPACK_ENABLE_DOWNLOAD_PROMPT=0
RUN corepack enable && corepack prepare yarn@stable --activate
# Set up yarn and corepack environment
ENV YARN_CACHE_FOLDER=/home/node/.yarn/cache
ENV YARN_GLOBAL_FOLDER=/home/node/.yarn/global
RUN mkdir -p /home/node/.yarn/cache /home/node/.yarn/global /home/node/.cache/node/corepack && \
    chown -R node:node /home/node/.yarn /home/node/.cache

# Install global packages
ENV NPM_CONFIG_PREFIX=/usr/local/share/npm-global
ENV PATH=$PATH:/usr/local/share/npm-global/bin

# Set up non-root user
USER node

# Install Claude Code
RUN npm install -g @anthropic-ai/claude-code
RUN mkdir -p /home/node/.claude

# Install Codex CLI(Native)
RUN npm install -g @openai/codex@native
ENV CODEX_RUST=1
RUN mkdir -p $HOME/.codex && \
    echo "Solve this TypeScript exercise. Read the test file to understand requirements and implement the solution." > AGENTS.md

# Install Goose CLI
RUN curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash
ENV HOME=/home/node
ENV PATH=$HOME/.local/bin:$PATH

# Install Aider
RUN curl -LsSf https://aider.chat/install.sh | sh
ENV AIDER_GIT=false
ENV AIDER_AUTO_COMMITS=false
ENV AIDER_SHOW_RELEASE_NOTES=false
ENV AIDER_SKIP_SANITY_CHECK_REPO=true
ENV AIDER_CHAT_HISTORY_FILE=""
ENV AIDER_INPUT_HISTORY_FILE=""

RESULT-aider-gpt-4.1-mini.md

❯ bun run src/index.ts --agent aider --model gpt-4.1-mini --exercise 100 --verbose

==================================================
📈 Benchmark Results
==================================================
🎯 Success Rate: 76.0% (76/100)
⏱  Average Duration: 169.3s
✅ Overall Success: 76
🤖 Agent Success: 99
🧪 Test Success: 76
❌ Failed: 24

📝 Detailed Results:
  ✅ accumulate                41.8s (🤖🧪)
  ❌ acronym                   51.6s (🤖❌)
  ✅ all-your-base             96.3s (🤖🧪)
  ✅ allergies                 52.2s (🤖🧪)
  ✅ alphametics               83.3s (🤖🧪)
  ❌ anagram                   42.3s (🤖❌)
  ✅ armstrong-numbers         74.2s (🤖🧪)
  ✅ atbash-cipher             52.4s (🤖🧪)
  ❌ bank-account              83.8s (🤖❌)
  ✅ beer-song                 45.2s (🤖🧪)
  ❌ binary-search             39.9s (🤖❌)
  ❌ binary-search-tree        44.6s (🤖❌)
  ✅ bob                       48.7s (🤖🧪)
  ❌ bowling                   1030.1s (🤖❌)
  ✅ circular-buffer           54.2s (🤖🧪)
  ✅ clock                     2892.3s (🤖🧪)
  ✅ collatz-conjecture        960.5s (🤖🧪)
  ❌ complex-numbers           55.9s (🤖❌)
  ❌ connect                   2113.2s (🤖❌)
  ❌ crypto-square             42.9s (🤖❌)
  ✅ custom-set                1012.6s (🤖🧪)
  ✅ darts                     167.3s (🤖🧪)
  ❌ diamond                   104.3s (🤖❌)
  ✅ difference-of-squares     948.9s (🤖🧪)
  ✅ diffie-hellman            56.2s (🤖🧪)
  ❌ dnd-character             50.2s (🤖❌)
  ✅ eliuds-eggs               41.8s (🤖🧪)
  ✅ etl                       42.9s (🤖🧪)
  ❌ flatten-array             37.7s (🤖❌)
  ❌ food-chain                83.5s (🤖❌)
  ✅ game-of-life              43.2s (🤖🧪)
  ✅ gigasecond                44.3s (🤖🧪)
  ✅ grade-school              50.4s (🤖🧪)
  ✅ grains                    44.3s (🤖🧪)
  ✅ hamming                   42.0s (🤖🧪)
  ✅ hello-world               68.1s (🤖🧪)
  ❌ house                     62.8s (🤖❌)
  ✅ isbn-verifier             93.1s (🤖🧪)
  ✅ isogram                   81.2s (🤖🧪)
  ✅ kindergarten-garden       47.6s (🤖🧪)
  ✅ knapsack                  48.1s (🤖🧪)
  ✅ largest-series-product    48.2s (🤖🧪)
  ✅ leap                      40.3s (🤖🧪)
  ✅ linked-list               65.1s (🤖🧪)
  ✅ list-ops                  64.2s (🤖🧪)
  ✅ luhn                      59.9s (🤖🧪)
  ✅ matching-brackets         45.3s (🤖🧪)
  ✅ matrix                    45.8s (🤖🧪)
  ✅ minesweeper               49.1s (🤖🧪)
  ✅ nth-prime                 42.6s (🤖🧪)
  ✅ nucleotide-count          42.0s (🤖🧪)
  ✅ ocr-numbers               52.8s (🤖🧪)
  ✅ palindrome-products       81.1s (🤖🧪)
  ✅ pangram                   44.3s (🤖🧪)
  ❌ pascals-triangle          141.9s (❌❌)
  ✅ perfect-numbers           82.5s (🤖🧪)
  ✅ phone-number              69.4s (🤖🧪)
  ✅ pig-latin                 53.8s (🤖🧪)
  ✅ prime-factors             44.2s (🤖🧪)
  ✅ protein-translation       92.3s (🤖🧪)
  ✅ proverb                   82.4s (🤖🧪)
  ✅ pythagorean-triplet       54.3s (🤖🧪)
  ✅ queen-attack              72.4s (🤖🧪)
  ✅ raindrops                 78.5s (🤖🧪)
  ❌ rational-numbers          58.6s (🤖❌)
  ❌ react                     122.0s (🤖❌)
  ❌ rectangles                53.9s (🤖❌)
  ❌ relative-distance         74.6s (🤖❌)
  ✅ resistor-color            76.6s (🤖🧪)
  ✅ resistor-color-duo        42.9s (🤖🧪)
  ✅ resistor-color-trio       75.6s (🤖🧪)
  ✅ reverse-string            40.9s (🤖🧪)
  ✅ rna-transcription         42.4s (🤖🧪)
  ❌ robot-name                47.5s (🤖❌)
  ✅ robot-simulator           53.7s (🤖🧪)
  ✅ roman-numerals            52.5s (🤖🧪)
  ✅ rotational-cipher         78.9s (🤖🧪)
  ✅ run-length-encoding       75.3s (🤖🧪)
  ✅ saddle-points             56.9s (🤖🧪)
  ✅ say                       53.2s (🤖🧪)
  ✅ scrabble-score            54.8s (🤖🧪)
  ✅ secret-handshake          345.6s (🤖🧪)
  ✅ series                    974.5s (🤖🧪)
  ✅ sieve                     949.0s (🤖🧪)
  ✅ simple-cipher             90.7s (🤖🧪)
  ✅ space-age                 114.8s (🤖🧪)
  ❌ spiral-matrix             60.0s (🤖❌)
  ✅ square-root               76.8s (🤖🧪)
  ✅ strain                    80.3s (🤖🧪)
  ✅ sublist                   50.1s (🤖🧪)
  ✅ sum-of-multiples          42.5s (🤖🧪)
  ✅ tournament                58.5s (🤖🧪)
  ❌ transpose                 80.7s (🤖❌)
  ✅ triangle                  78.9s (🤖🧪)
  ✅ twelve-days               49.6s (🤖🧪)
  ❌ two-bucket                79.2s (🤖❌)
  ✅ two-fer                   42.9s (🤖🧪)
  ❌ variable-length-quantity  61.9s (🤖❌)
  ✅ word-count                47.0s (🤖🧪)
  ✅ word-search               56.7s (🤖🧪)

RESULT-google-gemini-2.5-flash.md

>❯ bun run cli-agents-benchmark.ts --verbose  --agent goose --provider google --model gemini-2.5-flash --exercise 100

==================================================
📈 Benchmark Results
==================================================
🎯 Success Rate: 96.0% (96/100)
⏱  Average Duration: 102.2s
✅ Overall Success: 96
🤖 Agent Success: 100
🧪 Test Success: 96
❌ Failed: 4

📝 Detailed Results:
  ✅ accumulate                56.1s (🤖🧪)
  ✅ acronym                   97.3s (🤖🧪)
  ✅ all-your-base             76.8s (🤖🧪)
  ✅ allergies                 64.5s (🤖🧪)
  ✅ alphametics               88.2s (🤖🧪)
  ❌ anagram                   62.2s (🤖❌)
  ✅ armstrong-numbers         60.8s (🤖🧪)
  ✅ atbash-cipher             70.6s (🤖🧪)
  ✅ bank-account              61.3s (🤖🧪)
  ✅ beer-song                 88.1s (🤖🧪)
  ✅ binary-search             64.7s (🤖🧪)
  ✅ binary-search-tree        73.1s (🤖🧪)
  ✅ bob                       106.4s (🤖🧪)
  ❌ bowling                   169.6s (🤖❌)
  ✅ circular-buffer           69.3s (🤖🧪)
  ✅ clock                     79.3s (🤖🧪)
  ✅ collatz-conjecture        77.1s (🤖🧪)
  ✅ complex-numbers           177.7s (🤖🧪)
  ✅ connect                   491.3s (🤖🧪)
  ❌ crypto-square             84.4s (🤖❌)
  ✅ custom-set                109.4s (🤖🧪)
  ✅ darts                     70.1s (🤖🧪)
  ✅ diamond                   138.3s (🤖🧪)
  ✅ difference-of-squares     92.7s (🤖🧪)
  ✅ diffie-hellman            102.0s (🤖🧪)
  ✅ dnd-character             86.3s (🤖🧪)
  ✅ eliuds-eggs               69.5s (🤖🧪)
  ✅ etl                       70.4s (🤖🧪)
  ✅ flatten-array             68.9s (🤖🧪)
  ✅ food-chain                280.0s (🤖🧪)
  ✅ game-of-life              66.6s (🤖🧪)
  ✅ gigasecond                84.1s (🤖🧪)
  ✅ grade-school              85.9s (🤖🧪)
  ✅ grains                    77.1s (🤖🧪)
  ✅ hamming                   72.3s (🤖🧪)
  ✅ hello-world               67.5s (🤖🧪)
  ✅ house                     91.1s (🤖🧪)
  ✅ isbn-verifier             71.7s (🤖🧪)
  ✅ isogram                   68.6s (🤖🧪)
  ✅ kindergarten-garden       107.8s (🤖🧪)
  ✅ knapsack                  70.8s (🤖🧪)
  ✅ largest-series-product    72.7s (🤖🧪)
  ✅ leap                      70.0s (🤖🧪)
  ✅ linked-list               71.7s (🤖🧪)
  ✅ list-ops                  104.4s (🤖🧪)
  ✅ luhn                      74.0s (🤖🧪)
  ✅ matching-brackets         96.8s (🤖🧪)
  ✅ matrix                    96.1s (🤖🧪)
  ✅ minesweeper               81.0s (🤖🧪)
  ✅ nth-prime                 74.1s (🤖🧪)
  ✅ nucleotide-count          70.3s (🤖🧪)
  ✅ ocr-numbers               582.5s (🤖🧪)
  ✅ palindrome-products       161.3s (🤖🧪)
  ✅ pangram                   73.4s (🤖🧪)
  ✅ pascals-triangle          77.0s (🤖🧪)
  ✅ perfect-numbers           78.2s (🤖🧪)
  ✅ phone-number              87.4s (🤖🧪)
  ✅ pig-latin                 121.3s (🤖🧪)
  ✅ prime-factors             75.2s (🤖🧪)
  ✅ protein-translation       70.7s (🤖🧪)
  ✅ proverb                   154.3s (🤖🧪)
  ✅ pythagorean-triplet       264.7s (🤖🧪)
  ✅ queen-attack              92.9s (🤖🧪)
  ✅ raindrops                 71.5s (🤖🧪)
  ✅ rational-numbers          95.0s (🤖🧪)
  ✅ react                     297.5s (🤖🧪)
  ✅ rectangles                96.5s (🤖🧪)
  ✅ relative-distance         86.3s (🤖🧪)
  ✅ resistor-color            79.2s (🤖🧪)
  ✅ resistor-color-duo        72.4s (🤖🧪)
  ✅ resistor-color-trio       75.7s (🤖🧪)
  ✅ reverse-string            71.3s (🤖🧪)
  ✅ rna-transcription         72.0s (🤖🧪)
  ✅ robot-name                99.9s (🤖🧪)
  ❌ robot-simulator           92.0s (🤖❌)
  ✅ roman-numerals            79.1s (🤖🧪)
  ✅ rotational-cipher         73.1s (🤖🧪)
  ✅ run-length-encoding       73.5s (🤖🧪)
  ✅ saddle-points             94.1s (🤖🧪)
  ✅ say                       90.3s (🤖🧪)
  ✅ scrabble-score            68.9s (🤖🧪)
  ✅ secret-handshake          73.8s (🤖🧪)
  ✅ series                    96.0s (🤖🧪)
  ✅ sieve                     76.5s (🤖🧪)
  ✅ simple-cipher             104.8s (🤖🧪)
  ✅ space-age                 73.5s (🤖🧪)
  ✅ spiral-matrix             77.5s (🤖🧪)
  ✅ square-root               65.9s (🤖🧪)
  ✅ strain                    71.8s (🤖🧪)
  ✅ sublist                   85.6s (🤖🧪)
  ✅ sum-of-multiples          72.6s (🤖🧪)
  ✅ tournament                157.6s (🤖🧪)
  ✅ transpose                 192.5s (🤖🧪)
  ✅ triangle                  74.9s (🤖🧪)
  ✅ twelve-days               99.6s (🤖🧪)
  ✅ two-bucket                101.3s (🤖🧪)
  ✅ two-fer                   74.3s (🤖🧪)
  ✅ variable-length-quantity  124.7s (🤖🧪)
  ✅ word-count                75.7s (🤖🧪)
  ✅ word-search               115.7s (🤖🧪)