Skip to content
Multigrid

AI for developers & coding agents

What a model can and cannot do to a codebase, and the loops, context and review workflow that decide which of those you get.

A model writing code is doing the same thing it does everywhere else: producing a high-probability continuation of what it can see. Everything that makes it useful on a codebase, and everything that makes it dangerous there, follows from that one sentence. It can see the file you gave it and not the invariant nobody wrote down. It is rewarded for plausibility, and plausible code compiles. It has no way to tell the difference between the convention your team abandoned last year and the one it uses now, because both are in the repository.

So these pages are mostly about the parts around the model — what goes into the context, what shape the edit arrives in, what runs the tests, what stops the loop, and what a human is actually reviewing. Those are engineering decisions with right answers. Whether the whole arrangement makes anyone faster is a separate question with a genuinely contested literature, and it gets its own page rather than an assumption.

AI Coding Assistants: What They're Good and Bad At

A taxonomy of coding tasks by three properties that predict whether a model helps, and a rubric for scoring your own backlog against it.

5 min read

Autocomplete vs Chat vs Agent: Three Different Tools

What the latency budget, the context assembly and the edit format differ on between the three modes, and which kind of work each one is structurally suited to.

4 min read

Giving a Coding Model the Right Context

The token arithmetic of a repository against a context window, and how to build a ranked signature index that fits in the fraction you can afford.

4 min read

Reviewing AI-Written Code: A Checklist

Why review habits calibrated on human error miss model error, the eight classes that result, and two review moves that catch what reading cannot.

4 min read

Security Bugs LLMs Reliably Introduce

Nine CWE classes that follow from how a model is trained and prompted, with the mechanism for each, and the three published studies that disagree about how bad it is.

5 min read

Test Generation With LLMs: Beyond Coverage Theatre

Why generated suites raise coverage without raising confidence, and how to use mutation testing and case enumeration to get tests that assert behaviour.

4 min read

Refactoring Large Codebases With AI

How to slice a large refactor so that every step stays verifiable: codemods the model writes rather than applies, a ratchet that only moves one way, and expand-migrate-contract.

5 min read

Documentation Generation That Doesn't Restate the Code

Why generated docs paraphrase, where the intent a model needs actually lives in your repository, and how to make documentation fail the build when it goes stale.

4 min read

Migrating Between Languages and Frameworks With AI

A five-stage migration where recorded behaviour is the oracle, the pure core moves first, and both implementations run side by side before anything is deleted.

5 min read

Debugging With an LLM: Effective Patterns

Why pasting the stack trace gets you the population's most common cause rather than yours, and the hypothesis-and-discriminating-test loop that fixes it.

4 min read

AI in CI: Automated Review That People Don't Mute

Why precision rather than recall is the product for a review bot, the comment-budget arithmetic that follows, and the one honest metric for whether it is working.

4 min read

SWE-bench and Friends: Do Coding Benchmarks Predict Anything?

What SWE-bench actually contains and how it is graded, why a published number describes a model plus a scaffold, and how to build a thirty-task benchmark from your own merged pull requests.

5 min read

Context Windows and Big Repositories

Three retrieval layers for code in the order you should try them, why chunking source is not chunking prose, and the build-graph query that answers blast radius exactly.

4 min read

Building a Coding Agent That Can Run Tests

The four decisions that determine whether a test-running agent works: the patch format, the sandbox, the test command, and the stopping condition that is not a turn limit.

5 min read

Cost of an AI-Assisted Engineering Team

A per-developer cost model built from the three request shapes, including the quadratic transcript term that makes agent sessions cost what they do.

4 min read

Does AI Actually Make Developers Faster?

The four studies people cite, what each one actually measured, why they disagree, and how to run a credible measurement inside your own organisation.

5 min read

Technical Debt From AI-Generated Code

Why duplication and rework are the two metrics that move, what the one published corpus analysis can and cannot establish, and the commands to compute both on your own repository.

5 min read

Repo Instruction Files: What Actually Belongs in Them

AGENTS.md, CLAUDE.md and their equivalents are a prompt prefix paid on every request — what earns that price, what to delete, and how to stop the file going stale.

4 min read

AI for SQL and Data Work

Five layers of schema context ordered by token cost, the specific wrongness each one removes, and the guardrails that make a generated query safe to run.

4 min read

Pair Programming With a Model: A Working Method

A six-step loop with the correction happening at the plan rather than the diff, and five explicit triggers for stopping and reverting.

5 min read

Other topics