When AI does the junior work, how do we train seniors?
The Agentic Sweet Spot: Where AI Moves Fast and Humans Stay in the Loop
A recent Anthropic study on agent autonomy offers a clear preview of where knowledge work is headed. Anthropic analyzed millions of real interactions across their public API and Claude Code to see how people actually deploy autonomous systems. The catch is that their clearest view comes from Claude Code, where they can track longer workflows end to end. I treat their strongest takeaways as a snapshot of coding agents rather than a universal map of all professions. That distinction matters. Software development is the proving ground for autonomous work because it requires far less hand-holding. You can run tests, get immediate pass or fail feedback, roll back mistakes, and break large tasks into smaller steps using mature and well-defined tools.
Software is just the beginning of the story. To get a glimpse of what comes next, we can look at financial operations and contract management, two fields already governed by strict rules, standard templates, and mature systems. These domains serve as excellent test cases to answer a practical question: where can autonomous agents move fast, and where does human review remain essential?
Accounting Through Rules, Systems, and Exceptions
Accounting shares many of the structural advantages that make programming agent-friendly. The work operates under explicit, codified standards and policies that act like shared constraints. GAAP, IFRS, and tax codes define how transactions should be treated and recorded. Tasks decompose naturally into discrete, well-scoped subtasks with clear inputs and outputs. Reconciling an account, calculating depreciation, classifying a transaction, or preparing a tax schedule each have defined parameters and specific rules to follow.
Many of the mechanical steps are verifiable. A reconciliation either balances or it does not. Once inputs and classifications are set, many calculations can be checked against explicit rules. A journal entry either posts correctly or generates an error. The existing tooling is mature: ERP systems, general ledger software, and tax platforms expose structured data and APIs. An agent can pull invoices, match them to purchase orders, flag exceptions, draft follow-up requests, and attach supporting documentation. In practice, this works best with strong access controls and a clear audit trail. Reversibility is present too, though with caveats. An adjusting entry can fix a misclassified transaction, but the downstream implications for reporting, audit trails, and regulatory filings raise the stakes compared to a simple code rollback.
The real friction point is data quality and process maturity. Agents work best when inputs are consistent, documentation is complete, and policies are explicit. In many companies, source data arrives messy: incomplete invoices, missing receipts, conflicting bank feeds. Accountants spend significant time reconciling these discrepancies manually. An agent helps most when the company has already standardized data collection and approval workflows. The accounting function already treats auditability and traceability as first-class requirements, which fits naturally with agent logging and transparency. The practical deployment model mirrors existing practice: agents handle routine posting, matching, and documentation gathering, while CPAs focus on judgment calls, exceptions, and sign-off.
Why Contract Operations Are Agent-Friendly
Legal operations quietly built the exact same building blocks that make software automation possible. Contracts are built from templates and clause libraries. Redlines are standard, and changes are easy to compare, much like code diffs. Many companies already operate with standard fallback terms, risk acceptance matrices, and approval workflows. This is basically a template-plus-rules setup that agents can navigate.
An agent can identify contract deviations from company standards, extract key obligations, flag risky or non-standard terms, propose edits with explanations, and route work by risk tier to the right approver. In contracts, correctness means the agreement matches the company’s standards and risk posture. Reviewers can assess this by examining the deltas rather than reading entire documents, spot-checking high-risk clauses, and enforcing policy gates. The field already has mature tools for document management, document versioning, and audit trails, which align well with agent logging and transparency.
Genuine negotiation, novel legal interpretations, and edge cases still require attorney judgment. The sweet spot for agents is high-volume, templated work where terms follow known patterns. This works best when the company has already standardized clause libraries and clear acceptance criteria. Process maturity is the main constraint. Firms that have standardized templates and approval matrices will see faster value from agents. Humans stay in the loop for negotiation, exceptions, and final sign-off. In practice, agents handle initial screening and propose edits. Routine revisions are handled by the team, with escalations to senior counsel for complex negotiations and policy decisions.
The new bottlenecks in knowledge work
Coding, accounting, and contract operations share a pattern that shows up in more places than we might like to admit. When a job has clear inputs, explicit constraints, and cheap ways to verify results, agents take over the mechanical steps while humans shift toward review, prioritization, and exception handling. The organizations getting real leverage are not the ones writing the cleverest prompts. They are the teams treating agents like a production system by writing crisp specifications, forcing clarity up front, and making it easy to verify outputs before they hit a codebase, a financial ledger, or a contract repository.
The harder challenge is how this reshapes the company itself. As execution becomes practically free, the bottlenecks move to integration, quality assurance, and judgment calls. The core work becomes managing risk and coherence across a massive volume of machine-generated output. This forces leaders to build robust monitoring tools and tighten oversight precisely as they delegate more. It also creates a structural talent crisis. The entry-level tasks that historically trained junior employees are exactly the jobs agents do best. Companies will soon have to preserve manual skills intentionally just to ensure they still have people capable of troubleshooting when the automated systems inevitably fail.
Call for Speakers Closes March 20th
Ben Lorica edits Ethics.dev and the Gradient Flow newsletter, and he hosts the Data Exchange podcast. He helps organize the AI Conference and the AI Agent Conference, while also serving as the Strategic Content Chair for AI at the Linux Foundation. You can follow him on Linkedin, X, Mastodon, Reddit, Bluesky, YouTube, or TikTok. This newsletter is produced by Gradient Flow.
As it relates to research and trading, I think of it in three phases:
1. Senior staff accepts responsibility and accountability to train up those who come up behind them. Fundamentally, this is as it has always (or should have) been.
2. Quality Assurance: AI can do the work but hold the analyst accountable for the output--final and intermediate steps along the way.
3. Test and Tutor: Have analysts pass tests that confirm their knowledge before passing on whatever they are working on to the next step. AI is already quite capable of spinning up such tests and providing personalized tutoring on the fly.
Acquiring domain knowledge comes through the tedium, but with some forethought and execution, juniors can be better trained than ever before.