What the Human Still Does: Judgement, Keys, Taps and Two-Word Prompts

By October, 93% of the commits on the web portal were co-authored by an AI agent. That makes it fair to ask what the developer was actually doing all day. The answer turned out to be the most important part of the system.

Prompts got shorter as the harness grew

The median prompt on the portal was 24 characters. Typical prompts looked like this:

• "Look into ticket N."
• "go"
• "Merged. Cleanup. Next."
• a Figma link and one sentence
• a screenshot or a QA video, pasted with "is this caused by the bottom sheet?"
• a layout change, sketched in plain text:

| Icon | Title    |
| Subtitle        |

Prompts this short only work because the context lives in the harness: the ticket mirror, the instruction files, the session notes and memory. The developer stopped repeating context because the system already held it.

What the human decided

• Product judgement. "Remove the button. Those cases should go through official email for documentation." Another: dropping a proposed concept because it was "the most expensive, backend-driven, and not the app's intent".
• Where the truth lives. "Note the conflict, but follow the source code; it's what's running in production."
• Gaps in the backend. "No workaround. Build on what the backend provides and keep the unavailable parts disabled, maybe with a tooltip."
• Release safety. "Before merging, confirm all of this is flagged. I don't want half-baked frontend or backend in the app."
• Money. Billing figures and estimates of effort.
• The physical world. Logins, one-time passwords, taps on a real phone, and merges.

What the corrections were about

Across about 260 working sessions we collected roughly 80 moments where the developer pushed back. Very few were about code quality. Most fell into five groups:

• Domain meaning. A client term meant something other than what the agent assumed. Two concepts got mixed up across apps. "There is no admin path, it's the same path."
• Assumptions presented as facts. Guessing what unseen attachments contained, triaging from a stale ticket, citing an endpoint found in logs, or inventing a second timer: "The existing expiry *is* the window. There's no new timer."
• Scope. Too narrow, like changing one of two twin screens or one of two fields. Too wide, like rebuilding something that already existed: "Hmm, do we need this? I thought we already have drag-and-drop sorting."
• Communication. "I don't understand your sentence." "So, conclusion?" "What problem are you solving?" And, after a round of over-apologising: "Chill, I didn't blame you."
• Trust extended. When the agent offered to post review comments, the developer said: "No. Fix it, you have my permission."

The shape of that list matters. Code generation is now the easy part. The hard part is making sure the agent understands the domain, says what it doesn't know, and keeps to the right scope.

The human is the best reproducer

The agent had concluded it "could not reproduce" a vanishing-image bug. The developer came back with: "I reproduced it: kill the app, open View All, another row, back." Real bugs live in real sequences, and the people closest to QA find them fastest.

"go" is a protocol

On the portal, "go" and "Merged. Cleanup" made up about a third of all prompts. That works because the agent always stops at the same points: before committing, before touching shared environments, and before widening scope.

When "go" was ambiguous, the agent learned to state its reading first: "'go' most likely means the first option, so I'll commit and open the PR." Once, it guessed wrong and started an emulator. The developer interrupted with "Use real device", and that became a rule too.

Apprentice mode

If an agent writes everything, the people on the team stop learning the codebase. So we built an apprentice mode, a slash command that flips the roles:

• The human writes the code. The agent may not write any file, by any means.
• The agent teaches. It explains, reviews and asks questions.
• The mode survives resets. Every response starts with "Apprentice session active." so the mode survives context compaction.
• The principle behind it: "Retyping is not friction to be optimized away."

The same rules are mirrored for other agent tools, so the mode works whichever one is open.

More than one tool

Claude Code was the main agent, but the harness was never tied to it. GitHub Copilot reads path-scoped instruction files, and other agents read an AGENTS.md that defers to the same source of truth. The model in the loop moved through five generations during the year. The files, skills and habits stayed.

The harness compounds

The model changes every few months. What keeps compounding is what you build around it:

• rules that come from your own mistakes
• memory that survives a reset
• skills that turn "please test" into the agent's own job
• a ticket mirror that's safe to read
• release scripts that fail clean
• a human who stays in charge of judgement

That is what this series has described, and it's what we now install for other teams through harness engineering. If you'd like to talk through how your team works with AI today, get in touch.

What to copy

• Let prompts get short, by putting the context into the harness.
• Keep product judgement, money, keys and merges with people.
• Sort your corrections into groups, and fix the group, not the instance.
• Make "go" a protocol, with fixed stopping points.
• Protect learning with an apprentice mode.