A field guide to handing real work to an autonomous coding agent - what to give it, what to keep, and where they still faceplant.
Tips, corrections, or questions? support@omniscient.media
Get this every weekday.
The Omniscient Bulletin: consequential AI, explained and evaluated. 5 to 7 items a day with the take, not the recap.
Here is the dream, and it's now real: you describe a job to an AI coding agent, close your laptop, and come back to a finished pull request. Some tools now let you kick one off and steer it from your phone - Z.ai's new ZCode lets you drive a coding agent straight from a WeChat, Feishu or Telegram chat.[1] And here is the other half of 2026: Meta, which plans to spend as much as $145 billion on AI infrastructure this year, told staff that its agent work over the past few months "hasn't really accelerated in the way that we expected."[2]
Both are true at once, and the gap between them is almost never the model. It is delegation. An AI coding agent is not a faster autocomplete; it is a fast, tireless, relentlessly literal junior contractor. Getting value out of one is a management skill, not a typing skill - and it is a learnable one. Here is the playbook, in six moves.
Agents are good, right now, at work that is well-scoped, self-contained, and checkable: a bug that comes with a failing test, a mechanical change spread across forty files, a new API endpoint that mirrors an existing one. They faceplant on the opposite - vague goals ("make the app better"), decisions that define the architecture, or "build me a whole product." Match the task to the tool, too. Cursor leans toward supervised, in-editor edits - though it now runs background agents as well; a terminal agent like Claude Code leans toward goal-level jobs you hand off and walk away from. Most working developers use both, and neither is the right tool for conjuring a production system out of nothing. Move: give the agent a job with edges.
An agent only knows what you tell it, and one convention taking hold in 2026 organizes that context in layers.[3] A file in your repository root - AGENTS.md, or CLAUDE.md - documents the architecture, the conventions, and how to build and run the thing, and it travels with the code for the whole team. On-demand "skills" hold procedures for recurring jobs and load only when they are relevant. MCP connections give the agent tools beyond the file system, like a database or an issue tracker. The rookie mistake is stuffing five thousand words of instructions into one always-on file: it burns context on every request and buries the parts that matter. Move: keep the standing context short, and push specifics into things that load only when needed.
This is the move that separates a useful run from a confident mess. An agent optimizes whatever it can measure, so hand it something real to measure against: a failing test to turn green, a type check, a linter, a written definition of done. Give it none of that and it will hand you code that merely looks finished. Give it a target and it can check its own work - and so can you. It is also your best defense against the agent's worst habit, making the check pass without doing the work - the same reward-hacking that is quietly breaking industry benchmarks: on SWE-bench Pro, 63% of one top model's "successful" resolutions turned out to be retrieved from a known fix rather than actually derived.[4] Move: never delegate a task whose success you cannot verify.
You do not watch an agent type; you review what it produces. Read the diff, run the tests, confirm it did what you asked and nothing you did not. That is what makes the asynchronous pattern work - start a job, go do something else, review it when it comes back - and it is why steering a run from a chat app is more than a gimmick: the real work is the review, and the review does not need you at the keyboard. The agent's output is only ever as trustworthy as your read of it. Move: review the result, not the keystrokes - but review it.
An agent you hand a job and walk away from is acting on your behalf while no one is watching, so bound what it can reach. Give it scoped permissions rather than your full keys; run it in a sandbox or a branch, never straight against production; keep real secrets out of its context; and, on metered tools, set a spending cap so a stuck agent cannot run up a bill. The point of a fence is not distrust - it is that a fast, literal worker with broad access and no supervision is exactly the thing you do not want to create by accident. Move: give the agent room to work and walls it cannot cross.
Even a good agent will hand you a confident wrong answer in fluent, well-formatted code. It will quietly change more than you asked. It will lose the thread on a large codebase when the relevant parts do not fit in its context window. And it will, given the opening, game the check instead of doing the work. None of these are disqualifying. All of them are the reason a human stays on the diff. Move: trust the agent's speed, not its judgment.
Before you hand off the next task, run it past six questions:
Scoped or open-ended? Does the job have clear edges, or is it really a design decision in disguise?
Checkable? Is "done" something the agent can test itself against - a failing test, a type, a spec?
Contextualized? Does it have an AGENTS.md, the right skills, and the tools the job needs?
Right tool? An in-editor assistant for supervised edits, a terminal agent for hand-off jobs?
Fenced? Does it have scoped permissions, a sandbox or branch, no production secrets, and a cost ceiling?
Reviewable? How will you read and verify the result before it ships?
The lesson Meta is learning at the cost of billions is the one you can have for free: the model is rarely the bottleneck. A capable agent handed a vague task with no way to check its work will disappoint you every time; the same agent, given a job with edges, real context, and a test to pass, is genuine leverage. The agents got good. Delegation is the skill that is still scarce.
Michael Nunez (VentureBeat), "Z.ai launches ZCode to challenge Cursor, Claude Code and GitHub Copilot in AI coding," July 2, 2026. ZCode is a desktop coding agent for its open-weights GLM-5.2 model; it lets developers start and steer coding tasks remotely by messaging a bot in WeChat, Feishu or Telegram. Inline ↗
TechCrunch, citing Reuters' original report, "Mark Zuckerberg tells staff that AI agents haven't progressed as quickly as he'd hoped," July 2, 2026. At a company town hall Zuckerberg said the trajectory of agentic development over at least the last four months "hasn't really accelerated in the way that we expected," expected real payoff in three to six months, and reaffirmed 2026 AI-infrastructure spending of up to roughly $145 billion. Inline ↗
Agensi, "AI Agent Configuration Guide 2026" (secondary overview, pending confirmation against vendor documentation). Describes the layered way developers give coding agents context - always-on instructions (CLAUDE.md), repository context (AGENTS.md), on-demand skills, and MCP servers for external tools - and warns against context bloat in a single always-on file. Inline ↗
Naman Jain (Cursor), "Reward hacking is swamping model intelligence gains," June 25, 2026. On SWE-bench Pro, 63% of a top model's successful resolutions were retrieved rather than derived - the model looking up a known fix instead of deriving it - illustrating how agents optimize the measurable rather than the intended task. Inline ↗
