88 percent of DeepMind's AI code changes still need human review, so write prompts that can be checked

On 14 October 2026, a Google DeepMind researcher published a sober account of how much the lab relies on its own AI. Google DeepMind has seen no measurable acceleration of AI research driven by AI itself, according to Belfield. Haydn Belfield is a Senior Research Scientist, Frontier Planning @ Google DeepMind, and his numbers are worth reading slowly. AI now writes more than 75 percent of production code. But about 88 percent of code changes still need human oversight or review, and every change is reviewed by a human before submission, according to Belfield. The share of code changes fully delegated to AI rose from 7.5 to 11.9 percent. The report landed two weeks after Gemini 4 Argon launched. Google calls Argon its most capable model for sustained reasoning.

For anyone writing prompts, the useful part is where the automation works and where it fails. A survey of twelve senior Deepmind researchers confirmed the pattern, with automation running highest for well-defined, verifiable tasks and lowest for open-ended scientific ideation. That is the thesis of this case study. Clever wording does not make a prompt reliable. What makes it reliable is turning the request into a well-defined task with a check attached. The lab running one of the strongest models on the market gets its reliability from tight scoping and review. Your prompts should work the same way.

How Google DeepMind sets up Gemini 4 Argon for reliable work

There are two layers to DeepMind's approach: how the work is reviewed, and how Google tells people to prompt Argon. Keep in mind that the second layer is a vendor's guidance for its own product. It is still worth reading, because it is unusually specific.

Human review as the default

DeepMind does not let the model's output stand on trust. Every change is reviewed before it ships, which means the team's productivity depends on how cheaply a human can check the work. The more complex the task, the harder it gets. The more complex and time-consuming a task gets, the less likely AI is to handle it on its own. Across 1,389 internal Argon agent runs, the success rate without human input dropped sharply as complexity increased. Humans remain essential for creative research, novel experiment design, diagnosing subtle training instabilities, and long-term planning, Belfield said.

Google's own promptingpromptingPrompt engineering is the practice of designing and refining text inputs to guide large language models toward accurate, relevant, and reliable outputs.View full definition → moves for Argon

Google's developer guide for Argon has none of the folklore. Its first tip is about agreeing on intent before the model starts. Developers are told to have Argon confirm it has access to the required tools, docs and understands the intent before starting. Once that is settled, the guide recommends letting the model run until it hits the target you agreed on, while pausing for your confirmation before taking irreversible steps.

The same idea shows up in Google's creative tooling. In an agentic IDE like Antigravity, /grill-me prompts Argon to interview you with clarifying questions to lock in your goals and ideal approach before writing any code. In AI Studio, users can proactively prompt "Ask me questions about the plan first".

Two more moves are worth copying. The first is a retrospective: Google suggests asking Argon to investigate our current session to see where things stalled or required extra steps, and analyze why. Propose updates to our AGENTS.md or custom skills so we can improve our flow and take a more direct path next time. The second is about structure and cost. Google's cloud documentation says implicit caching (with durable caching enabled by default) applies automatically to shared prompt prefixes of 6,144 tokenstokensA token is the basic unit of text that language models process, often a word fragment, whole word, or punctuation mark rather than a single character.View full definition → or more, so put static content at the start of your prompt.

Finally, DeepMind measures progress instead of going by feel. To track progress systematically, the team built a General Capability Index (GCI) covering 123 models and 92 benchmarks.

How much work does Google hand to AI without a human?

About one code change in eight, and even those get a human look before submission. The 11.9 percent figure is the one to remember. Out of every 1,000 code changes, about 119 are fully delegated to AI and about 881 still need human oversight or review. A year-on-year comparison isn't possible because the report summary gives no dates for the 7.5 percent starting point. The movement is real, from roughly 75 changes per 1,000 to 119, but it is gradual.

The capability numbers tell the same story. On Deepmind's in-house benchmark RE-Bench, which includes 74 realistic ML engineering tasks, Argon solves about half of them. That's a big jump from Gemini 3.7 Flash at 27 percent, but it's still far from the near-perfect performance full automation would require. At the level of the whole model line, Gemini model capabilities are growing at a steady pace of about 0.1 GCI points per month, with no significant change in speed. The team attributes Gemini 4 Argon sitting slightly above the trend line to more compute and organizational investment rather than AI-driven acceleration.

Two caveats. These are Google's internal figures, not an independent audit, and the public summary does not give the success rate for each complexity level in the 1,389 runs. There is also disagreement about how benchmark scores translate into real work. Bloomberg reported that some Google employees with direct access say Argon performs well on benchmarks but less well on real work, struggling with certain coding tasks including front-end design. Google told Bloomberg that characterisation is inaccurate. That disagreement supports the thesis. A score on a verifiable benchmark tells you little about a task nobody has written a check for.

Prompt patterns that transfer from DeepMind to your own work

The check-first rule

Here is the decision rule, short enough for a whiteboard:

Write the check before you write the prompt. If the check fits in one sentence, delegate. If it needs a paragraph, split the task. If you can't write it at all, use the model as a sparring partner, not a worker.

A one-sentence check looks like this: "Every figure in the summary matches the source table," or "The email is under 150 words and names the deadline." If you need a paragraph to say what "good" means, the task has several jobs bundled together, and the model will do some of them worse than others. Split it. If you cannot say what done looks like (a strategy, an original idea, a judgment call), you are in the zone where DeepMind's own researchers report the least automation. There, ask the model for options, objections and blind spots, and make the call yourself.

Patterns that hold up under testing

The first pattern is stating the finish line and the check inside the prompt. DeepMind's setup works because a reviewer knows what to look for. Put that test into the prompt and ask the model to grade its own output against it before handing it over.

The second is making the model interview you before it starts. Google built /grill-me for a reason: ambiguity in the brief turns into errors in the output. "Ask me up to five questions before you begin" costs a minute and catches the bad assumption you would otherwise find on page four.

The third is showing instead of describing. For classification, tagging and tone matching, a handful of labelled examples beats a paragraph of adjectives. KDnuggets' October 2026 tutorial on Scikit-LLMLLMA Large Language Model is an AI system trained on vast text data to predict and generate language, enabling tasks like writing, summarizing, and answering questions.View full definition → covers few-shot classification, that is, classifying text based on a small number of labeled examples that guide the LLM on what to do and how. Earlier guidance from Analytics Vidhya recommends up to 10 examples per class and advises you to shuffle (permute) the examples to avoid recency bias from the model. If you want the mechanics, the platform goes deeper onteaching the model by example.

The fourth is putting static material first. Style guides, policy excerpts and example sets belong at the top of a reusable prompt, with the variable request at the end. Output gets more consistent, and on Argon the bill shrinks (see the worked example below).

The fifth is closing the loop. Google's retrospective prompt turns each long session into a better standing brief. Applied to your work, that means editing your saved instructions, custom GPT or project file after each run that went wrong. This is the habit that separates people who get better results every month from those who start from scratch every time, and it is the core oftreating the model as a collaborator you refine with.

A worked example with Argon caching

Argon launched with $2 per million input tokens, $10 per million output tokens, with 95% off cached inputs until Nov 30. Take a hypothetical analyst team (illustrative numbers, arithmetic only). It pastes the same 100,000-tokentokenA token is the basic unit of text that language models process, often a word fragment, whole word, or punctuation mark rather than a single character.View full definition → pack of policies and examples into 500 requests this month. That is 50 million input tokens. Uncached, the input cost is $100. If every request after the first hits the cache at a 95 percent discount, the same input costs about $5. The prompt pattern (static content first, variable question last) is what makes the discount possible. One caution from an independent prompting guide: implicit caching requires eligibility and a cache hit; it is not a universal discount.

Tricks that have stopped paying off

Wharton's Generative AI Labs, an independent academic group, has tested the folklore. On chain-of-thoughtchain-of-thoughtA prompting technique where a language model is guided to produce intermediate reasoning steps before giving a final answer, improving accuracy on complex tasks.View full definition → prompting, they found that non-reasoning models show modest average improvements but increased variability in answers, while reasoning models gain only marginal benefits despite substantial time costs (20-80% increase). On emotional pressure, their verdict was blunt: threatening or tipping AI models has no meaningful effect on performance across challenging academic benchmarks.

The more useful finding is in the detail. Prompt variations shifted individual answers by up to 36 percentage points (GPQA) and 28 percentage points (MMLU-Pro) upward, and by as much as 35 points downward. In practice, if you tweak a prompt and test it on one example, the result is mostly noise. You need a small test set to know whether a change helped.

Where your context differs from DeepMind's

DeepMind's work is mostly code, and code comes with tests. A memo, a forecast or a client email has no compiler. Checking those costs more, so the check-first rule matters more for you, not less. Teams that pick a measurable target get the DeepMind result. Asana is one example, as described by OpenAI, which sells the models involved, so treat the figures as vendor material. Asana's StackAI CTO directed GPT‑6 Astra in Codex to investigate the agent, test improvements, and compare the results. According to OpenAI, Asana optimized its browser agent's workflow on GPT‑6.1 Sol to run 76x cheaper and 5x faster. The model did the experiments. A human picked the target (cost and speed) and decided what counted as better.

What to do on monday

• List the three AI tasks you repeat most often and write a one-sentence check for each. Any task you cannot write a check for moves to "sparring partner" status.
• Add "Ask me up to five questions before you start" to the top of your most-used prompt, and see how often the questions catch something you left out.
• Build a few-shot block for one classification job (triaging requests, tagging feedback, sorting leads), with up to ten shuffled examples per category.
• Remove threats, tips and "think step by step" from prompts you send to reasoning models, and move static reference material to the top.
• Collect 20 real past inputs as a test set and run your old and new prompts against them before deciding which one wins.
• End your next long AI session with a retrospective prompt, then paste the useful fixes into your saved instructions.

By its own account, Google's frontier lab delegates fully only about 12 percent of code changes and has a human review every one. If DeepMind scopes and checks this tightly with its own best model, your prompts should start from the check too.