Let AI Agents Draft Instructions Without Losing Control

AI agents can now work from reusable, file-based instructions instead of receiving the same long prompt for every assignment. They can also draft and revise those files, but the safe operating model is supervised self-documentation: the agent proposes the playbook while a human retains authority over what becomes the approved version.

That distinction matters because “let the agent write 80% of its instructions” is a useful delegation heuristic, not a verified industry benchmark. The practical opportunity is real, but the percentage should not be treated as a promised saving or a measure of autonomy.

What an agent can actually write for itself

A reusable skill can contain the procedure, decision rules, examples, templates and supporting scripts needed for a recurring task. Current Claude Agent Skills documentation describes skills as filesystem-based packages that load when relevant; it also confirms that custom skills require a SKILL.md file and can include instructions, executable code and reference material.

This makes a productive division of labor possible. The human defines the outcome, constraints and evidence of success; the agent converts an observed working session into a structured draft. For a creator, that draft might cover how to turn an interview transcript into a newsletter: identify the central claim, preserve qualified language, flag unsupported numbers, follow the publication’s structure and return a final fact-check list.

The agent is well suited to capturing mechanical detail because it can inspect the files and steps used during the task. It can record naming conventions, required fields and repeated transformations without forcing the creator to reconstruct every action from memory. What it cannot determine by itself is whether those observed choices represent durable editorial policy or merely one acceptable solution to one assignment.

Delegate the draft, not the policy decision

The first run should produce two deliverables: the requested work and a proposed instruction file. Ask the agent to separate requirements it received explicitly from patterns it inferred while working. That provenance makes review faster: a hard rule such as “never invent a quotation” should not be mixed with a tentative preference such as paragraph length.

A useful proposal should contain:

the tasks that trigger the skill and the tasks outside its scope;
required inputs, permitted tools and expected output format;
quality checks that can be evaluated before delivery;
conditions that require a question or human approval;
examples of acceptable output and known failure cases.

Keep business judgment outside the agent’s unilateral control. It may propose a new tone rule after an editor rejects a draft, but it should not silently convert that single comment into a publication-wide standard. Likewise, an agent preparing sponsorship material may calculate options, but pricing authority, contractual commitments and claims about audience performance belong at an approval checkpoint.

Use a controlled learning loop

The operating loop is short, but each stage has a distinct owner:

Demonstrate: complete one representative task with enough guidance to expose the real workflow.
Extract: have the agent draft a reusable procedure and label inferred rules.
Test: run the proposed procedure on different examples, including an awkward edge case.
Review: compare outputs against explicit acceptance criteria rather than general impressions.
Approve: save the accepted revision as a named version with a brief change note.

This approach fits broader production guidance. Anthropic’s effective-agent engineering guidance distinguishes predictable workflows from agents that choose their own process, recommends clear success criteria and environmental feedback, and warns that autonomy can produce compounding errors. For repeatable creator work, a constrained workflow is often preferable to giving an agent unlimited discretion simply because the tool supports it.

Tests need not be elaborate. A newsletter skill could be checked against one clean transcript, one transcript with disputed statistics and one containing an ambiguous attribution. The evaluation asks whether the output meets observable requirements: every quotation matches the transcript, uncertain claims are flagged, the required sections are present and no publishing action occurs without approval.

Replace constant approvals with meaningful checkpoints

Micromanagement is not the same as oversight. Approving every harmless file read or formatting choice consumes attention without necessarily controlling the decisions that matter. A better design allows reversible work inside a defined workspace, while pausing before publication, payment, deletion, access changes or communication with an external person.

Research on real agent use supports this shift in supervision. In Anthropic’s February 2026 autonomy study, experienced Claude Code users employed full auto-approve more frequently but also interrupted the agent more often; the authors interpret that combination as movement from approving individual actions toward monitoring and intervening when necessary. The study is limited to one provider’s systems and heavily reflects software work, so its percentages should not be generalized to every creator workflow.

The transferable lesson is structural: reserve human attention for consequential transitions. Let the agent collect material, organize drafts, run checks and prepare a proposed skill update. Require a person to approve changes that broaden access, weaken verification, alter brand policy or cause an external action.

Do not let one correction rewrite the whole system

Feedback should enter the playbook as a proposed patch, not an invisible mutation. Ask the agent to show the previous rule, the proposed wording, the failure that motivated it and the tests affected. Small diffs are easier to evaluate than a regenerated instruction file in which unrelated requirements may have changed.

Versioning also makes experimentation recoverable. If a new procedure improves short videos but damages long-form scripts, the team can narrow its trigger or restore the earlier version. Without a revision history, a seemingly helpful correction can accumulate into contradictory instructions whose origin nobody remembers.

Some feedback should remain attached to the individual job. A client’s request for a warmer opening does not automatically become a universal tone rule; a one-off deadline exception is not a new scheduling policy. Promote a lesson into the shared playbook only when it reflects an enduring requirement, fixes a reproducible failure or succeeds across representative tests.

The durable management rule

Let the agent do most of the clerical work of instruction maintenance: extracting steps, drafting examples, identifying missing checks and preparing concise revisions. Keep human control over objectives, risk boundaries, approval rights and the decision to adopt each change.

The result is not an agent that manages itself. It is a governed workflow in which the machine maintains a proposed operating manual and the creator manages by outcomes, evidence and exceptions. That is enough to reduce repetitive prompting without pretending that a generated procedure is automatically a sound policy.

Let AI Agents Draft the Playbook—But Keep the Merge Button