AI can now capture an expert's hard-won judgment — but can people still become experts once the routine work is automated away?
Can tacit expertise be preserved when routine execution gets automated?
This explores whether the hard-to-articulate judgment experts carry can survive once AI takes over the routine work, both whether it can be captured in the AI system and whether people can still develop it.
This explores whether the hard-to-articulate judgment experts carry can survive once AI takes over the routine work, both whether it can be captured in the AI system and whether people can still develop it. The corpus says yes to the first and is much more worried about the second. Preserving what experts know today turns out to be easier than preserving the process that produces experts tomorrow.
Capturing expertise works better than you might expect. In one industrial case study, writing domain rules and design principles into an agent's scaffolding (the structured instructions and tools around the model) let non-experts produce work that experts rated at their own level, with quality up 206%. The gain came from the externalized expertise, not from a bigger model Can codified expertise let non-experts match specialist output?. Agents can also pull reusable routines out of their own past work and build on them Can agents learn reusable sub-task routines from past experience?. Source code can serve as raw material for skills that can be checked, even with no prior agent experience Can source code replace experience as skill raw material?. One project treats a specific person's distilled expertise as versioned files that can be inspected, corrected and rolled back. It also tracks what someone knows separately from how they act, so each can be audited on its own Can person-grounded skills remain auditable without hidden prompt state?.
What gets captured, though, is mostly procedure, not judgment. An analysis of more than 8,000 trials found that skills mostly work by keeping an agent's actions on track (65.7% of cases), not by supplying knowledge it was missing (4.5%). Skills fail when they're applied in the wrong context or followed too rigidly, which are exactly the situations where tacit judgment matters Do skills teach procedures or inject missing facts?. Even written-down knowledge can erode. Repeated summarizing and rewriting can quietly strip out the details that mattered, unless updates are made in small, curated steps Can context playbooks prevent knowledge loss during iteration?.
The deeper problem is a feedback loop that runs in two directions. Automating junior work removes the apprenticeship where people build the judgment needed to check AI output. Meanwhile, when experts label data for AI systems, they turn their own judgment into training data for their replacements, which narrows the chances for anyone to learn it the old way. Researchers call these the 'missing junior loop' and the 'codifier's curse' How does automating junior work destroy verification oversight?. This connects to Wei's 'verifier's rule': AI learns fastest on tasks whose answers are easy to check Does task verifiability determine what AI systems will learn to solve?. Tacit expertise is often the checking ability itself. So the more work AI absorbs, the more we depend on human verifiers, and the fewer new ones get trained.
The takeaway: tacit expertise can be stored in files and scaffolding, but the problem moves from storing knowledge to training new people. The open question in this collection is how organizations deliberately rebuild the apprenticeship that routine work used to provide. Some point to multi-agent setups with independent verification roles Do single agents always hit organizational limits?, but none of the retrieved work says how people learn to fill those roles.
Sources 9 notes
An industrial case study embedding domain rules and design principles into an LLM agent's scaffolding achieved 206% output-quality improvement and expert-level ratings from non-experts, bypassing the need for specialist oversight. The capability gain came from externalizing tacit expertise into structured harness components, not from model scale.
Agent Workflow Memory induces sub-task routines at finer granularity than full tasks, abstracts example-specific values, and compounds them hierarchically. This produces 24.6% relative gain on Mind2Web and 51.1% on WebArena, with larger gains as train-test gaps widen.
Code2Skill extracts over 1 million auditable skills from GitHub repositories through source-blind reconstruction verification, improving performance from 42.90 to 47.90 macro-average across eight benchmarks, outperforming trajectory and document-derived alternatives.
COLLEAGUE.SKILL treats distilled expertise as versioned files subject to inspection, correction, and rollback—not hidden prompt state. Separating capability tracks from behavior tracks enables independent audit of what someone knows versus how they act.
Analysis of 8,135 trials shows procedural anchoring accounts for 65.7% of skill cases versus 4.5% for knowledge injection. Skills fail when retrieved incorrectly, invoked out of context, or followed too rigidly.
Show all 9 sources
The ACE framework treats contexts as evolving playbooks using generation-reflection-curation loops rather than full rewrites. This prevents knowledge loss from compression and detail erosion, achieving +10.6% on agentic tasks and +8.6% on finance without labeled supervision.
Research identifies two feedback failures: automating entry-level work destroys the apprenticeship ground needed to build expert verifiers, and experts' own labels digitize their tacit judgment into replacements for themselves, narrowing future learning opportunities.
Wei argues that AI solves tasks proportional to how easily solutions can be verified, and that verifiability gaps can be narrowed by pre-investing in answer keys, test suites, or measurement infrastructure. This mechanism explains RL's effectiveness across domains from sudoku to molecular discovery.
Research shows that real-world tasks requiring heterogeneous expertise, parallel execution, and independent verification exceed what any single agent loop can organize. Graph-based system abstractions are needed to distribute intelligence across specialized agents.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Demystifying Agent Skills: Why They Work-Until They Don't
- RESOURCE2SKILL: Distilling Executable Agent Skills from Human-Created Multimodal Resources
- MUSE-Autoskill: Self-Evolving Agents via Skill Creation, Memory, Management, and Evaluation
- SkillOS: Learning Skill Curation for Self-Evolving Agents
- COLLEAGUE.SKILL: Automated AI Skill Generation via Expert Knowledge Distillation
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Repo-To-Skill: Distilling GitHub Repositories Into AI4AI Skills
- Agentic coding and persistent returns to expertise