Coding agents and computer-use agents

How it works: coding agents

1. Tools: read files, search the codebase (grep, glob), edit files (exact string replacement or patches), run shell commands (build, tests, linters), and git. Many coding agents also use subagents for exploration and review.
2. Instructions: the task plus the project's instruction file (AGENTS.md, CLAUDE.md) with build and test commands and rules (harness engineering).
3. The loop: explore the relevant code → plan → make a small edit → run the tests → read failures → fix → repeat → summarise.
4. Verification: tests, type checks and linters are the agent's ground truth; hooks can enforce "tests must pass before done".
5. Output: a branch and pull request with a clear description, reviewed by a human and checked by CI.
6. Run it safely: in a container or VM, with only the repository mounted, limited network, no production secrets (tool sandboxing).
7. Products (as of November 2026) include terminal and IDE agents (Claude Code, OpenAI Codex, GitHub Copilot's agent mode, Cursor and others) and cloud agents that work on issues and open PRs.

Vibe coding vs agentic engineering

1. Vibe coding (a term popularised in 2025): describing what you want, accepting whatever the AI writes without really reading it, and iterating on whether it seems to work. Great for throwaway prototypes and personal scripts.
2. The risk: code nobody understands, missing edge cases, security holes, and growing technical debt.
3. Agentic engineering: using agents seriously for production code. You write a clear spec, give the agent a good harness, insist on tests (often written first), keep changes small, review every diff, and let CI and evals gate merges.
4. The engineer's role shifts from typing every line to specifying, reviewing, testing and designing the loops, but responsibility for the code stays with people.

How it works: computer-use and browser agents

1. A computer-use agent gets a screenshot of the screen (in a virtual machine or container).
2. The model decides an action: click at (x, y), type text, press keys, scroll, or take another screenshot. Providers offer dedicated computer-use tools for this (as of November 2026, for example Anthropic's computer-use toolset and OpenAI's computer-use support).
3. The harness performs the action in the VM and returns a new screenshot.
4. Repeat until the task is done or a limit is hit.
5. Browser agents do the same in a web browser, often also reading the page structure (DOM or accessibility tree), which makes clicks more reliable than pixels alone; tools like Playwright drive the browser.
6. Be careful: web pages can contain indirect prompt injection; keep agents away from logged-in accounts and payments unless a human approves each sensitive step.
7. Prefer APIs when they exist: UI automation is slower, costlier and breaks when layouts change.

import re, subprocess, sys, tempfile, textwrap
from pathlib import Path
 
# The core loop of a coding agent: change code, run the tests, read the failure, try again.
with tempfile.TemporaryDirectory() as repo:
    src, tests = Path(repo, "price.py"), Path(repo, "test_price.py")
    src.write_text("def with_vat(net):\n    return net * 1.02\n")          # the bug: VAT is 20%
    tests.write_text(textwrap.dedent("""
        from price import with_vat
        def test_vat():
            assert round(with_vat(100), 2) == 120.0
    """))
 
    def run_tests() -> tuple[bool, str]:          # a tool the agent can call
        r = subprocess.run([sys.executable, "-m", "pytest", "-q", "-p", "no:cacheprovider"],
                           cwd=repo, capture_output=True, text=True)
        summary = re.search(r"\d+ (passed|failed)", r.stdout).group(0)   # e.g. "1 failed"
        return r.returncode == 0, summary
 
    ok, summary = run_tests()
    print("before fix:", summary)
    # The model reads the failure ("assert 102.0 == 120.0") and edits the file (an edit tool call).
    src.write_text(src.read_text().replace("1.02", "1.20"))
    ok, summary = run_tests()
    print("after fix :", summary, "-> ready for review" if ok else "")

before fix: 1 failed
after fix : 1 passed -> ready for review