GLM-5.2 vs. Kimi K2.7 Code: Which is better for coding? (2026)

python -m venv .venv

source .venv/bin/activate

.\.venv\Scripts\Activate.ps1

pip install openai "mcp>=1.27,<2"

Using the firecrawl_scrape tool, scrape {TARGET_URL} "
f"and extract: {FIELDS} for every book on the page. Return only a JSON "
f"array of objects, one per book, with those fields "
'here is some example json [{"title": "A Light in the Attic", "price": "£51.77", "availability": "In stock"}, '
'{"title": "Tipping the Velvet", "price": "£53.74", "availability": "In stock"}] '

"Build a GUI calculator web app as a single HTML "
"file (inline CSS/JS, no dependencies). Support +, -, *, /, and handle "
"invalid input gracefully. Return only the complete HTML file."

"Refactor the code you just wrote to the minimum "
"necessary for secure, maintainable software: no large if/else/switch "
"chains (use a lookup table), no dead code, no eval() on user input. "
"Return only the complete revised HTML file."

"Write a Python function returning the nth Fibonacci "
"number using memoization. Include a brief docstring. Return only code."

"""GLM-5.2 vs Kimi K2.7 Code harness. pip install openai "mcp>=1.27,<2" """
import json, time, os, csv, asyncio
from openai import OpenAI
from mcp.client.streamable_http import streamablehttp_client
from mcp import ClientSession
 
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="<your-openrouter-api-key>", timeout=60.0)
 
 
MODELS = {"glm-5.2": "z-ai/glm-5.2", "kimi-k2.7-code": "moonshotai/kimi-k2.7-code"}
FIRECRAWL_MCP_URL = "https://mcp.firecrawl.dev/v2/mcp"
FIRECRAWL_API_KEY = "<your-firecrawl-api-key>"
 
TARGET_URL, FIELDS = "books.toscrape.com", "title, price, availability"
GROUND_TRUTH = json.load(open("ground_truth.json", encoding="utf-8"))
 
RUN_ID = time.strftime("%Y%m%d_%H%M%S")
RUN_DIR = f"runs/{RUN_ID}"
CSV_PATH = "overall_results.csv"
CSV_FIELDS = ["run_id", "model", "task", "latency_sec", "input_tokens",
              "output_tokens", "valid_json", "matched_books", "book_total",
              "field_matches", "field_total", "runs", "error", "correct",
              "has_docstring", "fib30_calls", "memoized"]
 
TASKS = [
    #scrape a url using firecrawl mcp
    ("firecrawl_scrape", f"Using the firecrawl_scrape tool, scrape {TARGET_URL} "
     f"and extract: {FIELDS} for every book on the page. Return only a JSON "
     f"array of objects, one per book, with those fields "
     'here is some example json [{"title": "A Light in the Attic", "price": "£51.77", "availability": "In stock"}, '
     '{"title": "Tipping the Velvet", "price": "£53.74", "availability": "In stock"}] '),
 
    #build a calculator that runs client side in the browser
    ("calculator_build", "Build a GUI calculator web app as a single HTML "
     "file (inline CSS/JS, no dependencies). Support +, -, *, /, and handle "
     "invalid input gracefully. Return only the complete HTML file."),
 
    #refactor the calculator
    ("calculator_refactor", "Refactor the code you just wrote to the minimum "
     "necessary for secure, maintainable software: no large if/else/switch "
     "chains (use a lookup table), no dead code, no eval() on user input. "
     "Return only the complete revised HTML file."),
 
    #fibonacci test
    ("fibonacci", "Write a Python function returning the nth Fibonacci "
     "number using memoization. Include a brief docstring. Return only code."),
]
 
 
#save task output to an html file inside this run's own directory
def save_html(label, task, content):
    text = content.strip()
    if text.startswith("```"):
        text = text.split("\n", 1)[1].rsplit("```", 1)[0]  # strip code fences
    os.makedirs(RUN_DIR, exist_ok=True)
    path = f"{RUN_DIR}/{label}_{task}.html"
    open(path, "w", encoding="utf-8").write(text)
    print("saved", path)
 
 
#score a scrape result against ground truth, field by field
def score_scrape(content):
    text = content.strip()
    if text.startswith("```"):
        text = text.split("\n", 1)[1].rsplit("```", 1)[0]
    try:
        scraped = json.loads(text)
    except json.JSONDecodeError:
        return {"valid_json": False, "matched_books": 0, "field_matches": 0, "field_total": 0}
 
    by_title = {b.get("title"): b for b in scraped if isinstance(b, dict)}
    field_matches = field_total = matched_books = 0
    for truth in GROUND_TRUTH:
        entry = by_title.get(truth["title"])
        if entry is None:
            field_total += len(truth)
            continue
        book_correct = all(entry.get(k) == v for k, v in truth.items())
        matched_books += book_correct
        for k, v in truth.items():
            field_total += 1
            field_matches += entry.get(k) == v
 
    return {"valid_json": True, "matched_books": matched_books,
            "book_total": len(GROUND_TRUTH), "field_matches": field_matches,
            "field_total": field_total}
 
 
#extract and run the fibonacci function, checking correctness + real memoization
def score_fibonacci(content):
    text = content.strip()
    if text.startswith("```"):
        text = text.split("\n", 1)[1].rsplit("```", 1)[0]
 
    namespace = {}
    try:
        exec(text, namespace)
    except Exception as e:
        return {"runs": False, "error": str(e)[:200]}
 
    name = next((k for k, v in namespace.items()
                 if callable(v) and "fib" in k.lower()), None)
    if name is None:
        return {"runs": False, "error": "no fibonacci function found"}
 
    expected = {0: 0, 1: 1, 10: 55, 20: 6765}
    try:
        correct = all(namespace[name](n) == v for n, v in expected.items())
    except Exception as e:
        return {"runs": False, "error": str(e)[:200]}
 
    # wrap the function under its own name so every recursive self-call,
    # which is resolved by name lookup at call time, gets counted too
    calls = [0]
    original = namespace[name]
    def counted(*args, **kwargs):
        calls[0] += 1
        return original(*args, **kwargs)
    namespace[name] = counted
    result = counted(30)
    n = 30
    # generous bound: real memoization (recursive-with-cache or iterative)
    # stays roughly linear in n; naive recursion is exponential and blows past it
    memoized = calls[0] <= 5 * n + 10
 
    return {
        "runs": True,
        "correct": correct,
        "has_docstring": bool(getattr(original, "__doc__", None)),
        "fib30_calls": calls[0],
        "memoized": memoized,
    }
 
 
#append one task's metrics as a row to the cumulative CSV (across all runs)
def append_csv_row(meta):
    row = {k: meta.get(k) for k in ("model", "task", "latency_sec",
                                     "input_tokens", "output_tokens")}
    row["run_id"] = RUN_ID
    row.update(meta.get("score", {}))  # flattens scrape-score fields if present
    is_new = not os.path.exists(CSV_PATH)
    with open(CSV_PATH, "a", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=CSV_FIELDS)
        if is_new:
            writer.writeheader()
        writer.writerow(row)
 
 
#basic model call wrapper
def call_model(model_id, messages, tools=None):
    start = time.time()
    kwargs = {"model": model_id, "messages": messages}
    if tools:
        kwargs["tools"] = tools
    resp = client.chat.completions.create(**kwargs)
    usage = resp.usage
    return resp.choices[0].message, {
        "input_tokens": usage.prompt_tokens,
        "output_tokens": usage.completion_tokens,
        "latency_sec": round(time.time() - start, 2),
    }
 
#run scrape a site using firecrawl
async def run_firecrawl_task(model_id, prompt):
    print("  connecting to firecrawl mcp...")
    headers = {"Authorization": f"Bearer {FIRECRAWL_API_KEY}"}
    async with streamablehttp_client(FIRECRAWL_MCP_URL, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            print("  listing tools...")
            listed = await session.list_tools()
            tools = [{"type": "function", "function": {
                "name": t.name, "description": t.description, "parameters": t.inputSchema}}
                for t in listed.tools]
 
            print("  calling model (initial)...")
            history = [{"role": "user", "content": prompt}]
            msg, meta = call_model(model_id, history, tools=tools)
            history.append(msg)
            for tc in msg.tool_calls or []:
                print(f"  calling tool: {tc.function.name}...")
                result = await session.call_tool(tc.function.name, json.loads(tc.function.arguments))
                history.append({"role": "tool", "tool_call_id": tc.id, "content": result.content[0].text})
            if msg.tool_calls:
                print("  calling model (final, with tool result)...")
                msg, meta2 = call_model(model_id, history)
                meta["latency_sec"] += meta2["latency_sec"]
            return msg.content, meta
 
 
#loop through the model tasks
def main():
    results = []
    for label, model_id in MODELS.items():
        history = []
        for task, prompt in TASKS:
            if task == "firecrawl_scrape":
                content, meta = asyncio.run(run_firecrawl_task(model_id, prompt))
                meta["score"] = score_scrape(content)
            else:
                history.append({"role": "user", "content": prompt})
                msg, meta = call_model(model_id, history)
                content = msg.content
                history.append({"role": "assistant", "content": content})
            meta.update(task=task, model=model_id, content=content)
            if task == "fibonacci":
                meta["score"] = score_fibonacci(content)
            results.append(meta)
            print(label, task, meta["latency_sec"], "s")
            if task in ("firecrawl_scrape", "fibonacci"):
                print("  score:", meta["score"])
            if task in ("calculator_build", "calculator_refactor"):
                save_html(label, task, content)
            append_csv_row(meta)
            if task != "calculator_build":
                history = []  # reset context except going into the refactor step
 
    #save this run's full metadata inside its own directory too
    os.makedirs(RUN_DIR, exist_ok=True)
    json.dump(results, open(f"{RUN_DIR}/results.json", "w"), indent=2)
    print(f"Saved {RUN_DIR}/results.json and appended to {CSV_PATH}")
 
 
if __name__ == "__main__":
    main()

function compute(a, b, op) {
      let x = Number(a), y = Number(b);
      if (!isFinite(x) || !isFinite(y)) return null;
      let r;
      switch (op) {
        case '+': r = x + y; break;
        case '-': r = x - y; break;
        case '*': r = x * y; break;
        case '/':
          if (y === 0) return null; // division by zero
          r = x / y; break;
        default: return null;
      }
      if (!isFinite(r)) return null;
      // round to avoid floating noise
      r = Math.round(r * 1e12) / 1e12;
      return r;
    }

const OPERATIONS = {
      '+': (a, b) => a + b,
      '-': (a, b) => a - b,
      '*': (a, b) => a * b,
      '/': (a, b) => (b === 0 ? null : a / b)
    };

function calculate() {
    const raw = display.value.trim();
    if (!raw) return;
 
    if (!/^[0-9+\-*/.()]+$/.test(raw)) {
        display.value = 'Error';
        return;
    }
 
    try {
        const result = new Function('return (' + raw + ')')();
 
        if (!Number.isFinite(result)) {
            display.value = (result === Infinity || result === -Infinity)
                ? 'Cannot divide by zero'
                : 'Error';
            return;
        }
 
        display.value = String(result);
    } catch (err) {
        display.value = 'Error';
    }
}

function evaluate(input) {
    const tokens = tokenize(input);
    let i = 0;
 
    const current = () => tokens[i];
    const next = () => tokens[i++];
 
    const expression = () => {
        let value = term();
        while (current() && (current().value === '+' || current().value === '-')) {
            const op = next().value;
            value = op === '+' ? value + term() : value - term();
        }
        return value;
    };
 
    const term = () => {
        let value = factor();
        while (current() && (current().value === '*' || current().value === '/')) {
            const op = next().value;
            if (op === '*') {
                value *= factor();
            } else {
                const divisor = factor();
                if (divisor === 0) throw new Error('Cannot divide by zero');
                value /= divisor;
            }
        }
        return value;
    };
 
    const factor = () => {
        const token = current();
        if (!token) throw new Error('Unexpected end');
 
        if (token.type === 'number') { next(); return token.value; }
        if (token.value === '+') { next(); return factor(); }
        if (token.value === '-') { next(); return -factor(); }
        if (token.value === '(') {
            next();
            const value = expression();
            if (!current() || current().value !== ')') throw new Error('Missing )');
            next();
            return value;
        }
 
        throw new Error('Invalid syntax');
    };
 
    const result = expression();
    if (i < tokens.length) throw new Error('Unexpected token');
    return result;
}