Coding & Computer-Use Agents

Coding Agent Architecture

The localize-edit-verify loop that makes a coding agent more than a code generator: the agent-computer interface, why agentic beats pipeline coding, and where the loop fails.

Repo Navigation & Code Context

Code search vs. embeddings, symbol-level indexing, context budgeting over a large tree, and why confident wrong localization is the expensive failure of code retrieval.

Patch Generation & Test-Driven Loops

Structured diffs and hunk-apply failures, test-driven self-correction, regression guarding, and the three honest liars in the loop: flakes, overfit, and the deleted assertion.

Computer-Use & GUI Agents

Pixel vs. DOM grounding, the action space, the screenshot loop, and the multiplicative latency and reliability tax that makes GUI control a last resort.

Browser agents

Driving a real browser as a tool — DOM versus pixel observation, login + auth state, the well-trodden failure modes, and when to step up to a full GUI agent.

IDE agents

Coding agents that live in the editor — the loop is the same as a CLI coding agent, but the interaction surface, undo expectations, and trust threshold are all different.

Sandboxing & Safe Execution

Containerized execution, network and filesystem isolation, capability scoping, and designing for blast radius when an agent runs untrusted, attacker-influenced code.

Evaluating Coding Agents

The SWE-bench family, pass@k vs. resolve rate, harness sensitivity, documented contamination, and why a private post-cutoff eval set is the only number to trust.

Code Review Agents

A review bot lives or dies on precision, not recall: diff-anchored context, an adversarial gate that drops any finding without a concrete failure scenario, a hard comment budget ranked worst-first, and acted-upon rate as the one production metric.

Large-Scale Migration Agents

Generation went to zero and human review did not, so the deliverable is evidence rather than patches: build the oracle first, batch by verifiability instead of by directory, hand the mechanical head to a codemod and only the tail to the model, and let a hundred-file pilot’s unedited-merge rate decide whether the project is viable.

Debugging & Triage Agents

An agent that reads a stack trace and emits a diff has pattern-matched, not debugged — make the failing test the deliverable and the eval criterion becomes objective, the spend moves from generation to observation, and "cannot reproduce" becomes a result you can trust.

Background Coding Agents

An agent that opens twelve pull requests a day adds nothing if your team merges four — detaching from the editor moves the bottleneck to review, so every decision is either about making a run self-verifying or about keeping the queue short enough that the work lands.

Test-Generation Agents

An agent that writes tests from your code infers the spec from the implementation, so wherever the code is wrong the test now certifies the bug and blocks the fix — coverage cannot see this, mutation score can, and the only jobs worth dispatching are the ones where you can name the oracle in a sentence.

Dependency Upgrade Agents

Bumping a version has been automated since 2017 and is worth nothing — the backlog exists because nobody will merge an upgrade they cannot vouch for, so what you are building is an evidence policy: a green suite proves least about the changed defaults that break silently, and correct triage beats upgrades merged.

Documentation Agents

Documentation is the one artefact in the repo with no oracle, and a wrong paragraph gets believed for years — so split the corpus by what a machine can falsify, give the agent unsupervised authority over derived reference and executable prose only, make deletion a first-class output, and report freshness rather than pages written.