Skip to content
AI Coding 2026: 6 Practices for Human Oversight of Autonomous Agents

AI Coding 2026: 6 Practices for Human Oversight of Autonomous Agents

This article synthesizes 2026 AI coding best practices from Thorsten Ball, Tw93, and Amp into six key workflows: clarifying goals and constraints, running verification alongside development, reviewing by impact scope, monitoring abstractions and state, releasing incrementally with observation, and planning recovery beyond code rollback.

Architect
Architect
Architect

The article synthesizes recent AI coding practices from Thorsten Ball’s October 2026 essay, Tw93’s “21 AI Coding Best Practices for 2026,” and the Amp video demonstration into six actionable workflows. The central question: when an agent works continuously, what should humans watch and when should they intervene? The author frames the answer around three lenses: can errors be discovered, how far does impact spread, and can we roll back.

1. Clarify Goals and Constraints, Leave Room for Implementation

Using a hypothetical “add order export for operations” task, the author shows that a vague prompt lets the agent build a working download button but misses critical constraints: tenant isolation, permission checks, and not altering the order write path. The solution is to explicitly state the hidden requirements:

Add an order export entry for operations, supporting current filter results. Reuse existing tenant and data permissions; do not change the order write flow. First examine existing query, permission, and file download implementations, explain what will be reused and what will be affected, then implement. Acceptance must cover normal download, cross-tenant access, and unauthorized access.

Implementation details can be negotiated; business constraints must be explicit. Recurring constraints should be added to AGENTS.md or CLAUDE.md — not just directory structures, but permission entry points, rejected design rationales, and how to run related tests. The author notes that writing rules doesn’t guarantee the next agent will use them; in the Amp video, an agent initially thought it couldn’t access the E2B sandbox. The fix: create ten new Orbs (Amp’s ephemeral environments), verify the new session finds the information, and include a control group. For ordinary projects, start smaller: open a new session, ask the agent to locate the permission entry and verification command, and confirm it finds them correctly. Real enforcement still relies on server-side validation and tests.

2. Run Verification Alongside Development, Deliver Actual Results

Asking “did you test?” after the fact is too late. Pre-existing test failures may be blamed on the new change; existing exceptions might be silently fixed, bloating the scope. Simon Willison’s habit: start a new session by running tests to capture the baseline. Record existing failures, then re-run the same command after changes to isolate new issues. Missing dependencies or connectivity problems also get a concrete starting point.

Don’t always run the full expensive suite. For order export, run order query, permission, and download checks first; expand if shared modules are touched. If no tests exist, leave a script that reproduces current behavior. The agent must be able to start the project, fetch logs, and self-correct; otherwise human handoffs will constantly interrupt.

The Amp video demonstrates concrete verification: the agent starts the dev server, writes scripts, launches the runtime, exchanges messages, compares behavior between main branch and refactored version, and lists tested scenarios with results. This shows tested scenarios have no regressions , not that all inputs are safe.

For order export, “download succeeds” is insufficient. At least four verification dimensions are needed:

Content correctness: Export with known orders and filters; verify order numbers, quantities, fields; also test empty results.

Permission validity: Switch tenants, use unauthorized accounts, directly call export and download endpoints; confirm no unauthorized data access.

Failure handling: Simulate query or file generation failures; check error messages, temporary file cleanup, and task state handling.

Impact on existing requests: Under agreed data volume and concurrency, measure export latency while monitoring original order query performance.

These checks should be returned with the change. Worth preserving: environment run, repeatable commands/scripts, actual output, untested items. Mock services must be noted; screenshots cannot replace file content and permission checks.

If a bug persists after two fixes, shift focus to diagnosis: record reproduction steps, key logs, actual data; have the agent list possible causes and verification steps. Find the cause that explains the phenomenon, then fix. Keep the reproduction script as a new repeatable check.

More useful than “tests pass” is knowing what was run and what wasn’t.

3. Allocate Review Effort by Impact Scope

Line count is a poor proxy for risk. A few dozen lines might touch a shared permission function used by all queries; hundreds of style changes may stay on one page. With run results in hand, the next step is to map the call chain: entry points, callers, shared data, and file locations. Having the agent explain this path is more useful than a file-by-file diff summary.

For order export, the path includes: request entry, tenant/permission validation, order query, file storage, download access verification. If background jobs are used, trace how the job reads user and tenant context.

Export and download requests each pass server-side permission checks, hypothetical order export example
Export and download requests each pass server-side permission checks, hypothetical order export example

Export and download requests each pass server-side permission checks, hypothetical order export example

Walking this path reveals gaps: the page may enforce permissions, but does the download endpoint? The job creation may check permissions, but does execution still carry the tenant condition?

If only adding a page and reusing existing interfaces, verify demo, tests, and call correctness. If modifying shared permissions, trace all callers — original queries and detail pages. Database migrations need separate review for data changes, compatibility, and rollback.

The video’s reduced line-by-line review relies on test matrices, logs, demos, and the author’s familiarity with core code. For unfamiliar projects, copying “only read a few files” is unsafe.

What determines review depth is which functions and data will change.

4. Architecture: Watch Abstractions, Dependencies, and State Ownership

Some issues surface months later. Example: writing a separate permission filter for export. Today both rules match; later the query permission changes — will export be updated? Or building a generic task framework for one feature; other code starts depending on it, turning a local change into a public interface.

After mapping impact, ask what the change leaves behind. For new public layers or duplicated state:

What exactly is missing in the existing module? Is it truly impossible, or just no entry point found yet?

Who will call the new interface? Will originally independent modules become coupled?

Will the same rule or business state have two owners responsible for modifications?

Reuse doesn’t mean forcing all needs into old modules. If the existing query returns all data at once but bulk export needs streaming, adding streaming capability may be justified. But first discuss reusing permission and query logic, only adding the read path, not building a whole new order query.

The Claude Code team retains human review for “architectural decisions that become future templates.” The author agrees: such changes deserve early scrutiny because agents mimic existing repo patterns; the first public interface sets a precedent that quickly attracts more callers.

5. Small Releases with Observation and Kill Switches

The Amp video ends with a memory alert case: the agent investigates Orb OOM, improves warnings, lists top memory consumers, then puts the feature behind a feature flag, deploys to production, and enables it only for the author.

The agent then spins up several Orbs, fills memory to reproduce the issue; the author checks warnings and the stop button. The author notes this isn’t done every time.

Even after tests and reviews, real environments have conditions hard to replicate. Small-scope enablement buys time to detect problems and stop them.

Order export can start with test accounts or a first user cohort, with agreed data volume, concurrency, and timeouts. Observe task success rate, latency, resource usage, and watch for slowdowns in original order queries. Few users doesn’t mean small impact on shared resources.

Define stop conditions upfront: immediate disable on unauthorized data; latency, error rate, and shared resource thresholds per existing project alerts. This gives concrete criteria to decide whether to continue watching, expand, or stop.

If tooling supports scheduled checks, have the agent verify metrics at agreed intervals. First confirm it can actually read the relevant logs and metrics; if it can’t, “running fine” is not acceptable. Subsequent scope changes or rollbacks follow existing project authorization.

Whether a small-scale trial helps depends on timely problem detection and the ability to stop.

6. Recovery Plans Must Extend Beyond Code

Keeping each change to a single small feature makes it easier to understand and revert individually. Bundling order export with a shared query refactor in one commit muddies what to keep when things break.

But splitting commits only solves part of code rollback. An order export incident involves three distinct recovery actions:

Stop the feature first. Server blocks new export requests; if background jobs exist, decide whether to cancel running jobs and how to stop them. Hiding the button is insufficient — direct API calls can still trigger exports.

Then assess code rollback. Which commit to revert, which version to restore — be specific. If the database changed, can the old version read the new data? That affects rollback choice.

Finally handle already generated data and files. Clean up temp files from failed jobs; revoke access to generated files. If unauthorized download already occurred, code rollback won’t retrieve that data.

After code rolls back to old version, generated files still exist and need separate access restriction and cleanup
After code rolls back to old version, generated files still exist and need separate access restriction and cleanup

After code rolls back to old version, generated files still exist and need separate access restriction and cleanup

No database migration and no background jobs simplifies recovery. Explicitly stating what’s involved lets the next person know what “rollback on exception” actually entails.

For billing, messaging, or data deletion, consider consequences that code rollback doesn’t undo: money isn’t refunded, messages aren’t unsent. Checks for these side effects belong before expanding rollout.

The opening deployment example worked because the author had runtime feedback and an executable recovery plan. The prerequisite for delegating tasks: the agent must return results sufficient for judgment.

For ordinary projects, two questions remain: Can the agent run the project on its own? Does it return repeatable results? With those, gradually reduce intervention based on code familiarity and impact scope. Decisions involving permissions, shared rules, and state ownership still warrant a dedicated look.

References

Thorsten Ball, How I work with Agents , 2026-10-25 (https://x.com/thorstenball/status/2114386050638336082)

Amp, How Thorsten Ball Uses Amp, October 2026 , 2026-10-13 (https://www.youtube.com/watch?v=Z7l1EHfCMU8)

Tw93, 2026 年,我的 21 条 AI Coding 最佳实践 , 2026-10-29 (https://tw93.fun/2026-10-29/practice.html)

Addy Osmani, Morgan Westlee Lunt, Qing Wang, How the Claude Code team does code review , 2026-10-15 (https://claude.dev/blog/solving-code-review-at-anthropic/)

Simon Willison, First run the tests (https://simonwillison.net/guides/agentic-engineering-patterns/first-run-the-tests/)

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

AI agentsAI codingcode reviewBest PracticesVerificationsoftware development practicesRollback Strategiesincremental release
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.