New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Deviate

by agentculture in agentculture/culture

Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only…

Apache-2.0Auto-check passed

Install Deviate

skills CLI
$ npx skills add agentculture/culture --skill deviate -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install agentculture/culture deviate --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/agentculture/culture.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/deviate .claude/skills/deviate && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
deviate
GitHub stars
113
Token cost
~2.4k tokens
SKILL.md length
1,121 words
Files
1
Skills in repo
18
Repo updated
First seen
Licence
Apache-2.0

At a glance

Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only…

  • Works in 6 steps: STOP the run. The moment a task agent… → Present what, why, and what it affects.… → Get explicit human approval. This is the… → …
  • The user says deviate from the plan
  • SKILL.md covers The method, The shipped CLI surface, Hard rules (do not violate) and Worked example, plus 2 more sections
  • Calls uv

What it does

Deviate is an agent skill from agentculture/culture. Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only deviation record via devague deviate before resuming — never fold a deviation silently into drift after the fact. Use when the user says "deviate from the plan", "we need to change the plan mid-run", "record a deviation", "this isn't matching the plan anymore", or when a task agent discovers the confirmed plan no longer…

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: Culture turns isolated stochastic agents into cooperative, inspectable, improvable artificial colleagues. The licence is Apache-2.0.

When your agent uses it

  • The user says deviate from the plan
  • We need to change the plan mid-run
  • Record a deviation
  • This isnt matching the plan anymore

Example prompts

  • “deviate from the plan”
  • “we need to change the plan mid-run”
  • “record a deviation”
  • “/deviate”

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. STOP the run. The moment a task agent (or the main agent) discovers
  2. Present what, why, and what it affects. Lay out, for the human
  3. Get explicit human approval. This is the one non-negotiable step. A
  4. Record it via devague deviate. Once approved, record the deviation
  5. Adjust the affected task briefs. Update the working instructions the
  6. Resume. Only after the record exists (and, for an llm-origin record,

What it can do on your machine

Read from SKILL.md and the folder at commit d5b5715. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • uv

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use uv, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Deviate loads about 2.4k tokens when it runs. Until then it costs about 198 tokens; SKILL.md has 1,121 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~198
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from agentculture/culture at commit d5b5715, republished under its Apache-2.0 licence (© agentculture). 1,121 words, ~2,429 tokens.

Download SKILL.mdSave it as .claude/skills/deviate/SKILL.md (or your agent's skills folder).
name
deviate
description
Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only deviation record via `devague deviate` before resuming — never fold a deviation silently into drift after the fact. Use when the user says "deviate from the plan", "we need to change the plan mid-run", "record a deviation", "this isn't matching the plan anymore", or when a task agent discovers the confirmed plan no longer matches reality partway through a workforce run. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.
type
command

deviate — record an approved mid-run departure from the confirmed plan

The skill is named deviate; it is the execution-time leg of the devague method — the sixth leg, sitting between the two execution skills:

text
scope -> think -> spec-to-plan -> assign-to-workforce -> deviate -> summarize-delivery

Where /assign-to-workforce fans out a converged plan's waves and /summarize-delivery closes the loop afterward, /deviate runs during the fan-out, at the exact moment reality stops matching the plan the human approved at gate 2 (the implementation split plan). It is not a new standing gate — it is the human owner of gate 2 amending the approved split mid-flight, scoped to the one deviation in front of them.

The plan the user confirmed is a contract. Task agents hit constraints, discover a dependency was wrong, or find the acceptance criteria no longer make sense once code is in front of them. Until this skill existed, that reality either silently reshaped what got built (undocumented drift) or the run stalled with no recorded path forward. /deviate is that path: the departure is named, approved, and recorded before anyone keeps building against it.

The method

  1. STOP the run. The moment a task agent (or the main agent) discovers the confirmed plan no longer matches what needs to happen, halt — do not keep implementing against the stale contract and do not let the fan-out continue past this task.
  2. Present what, why, and what it affects. Lay out, for the human:
    • what is diverging — the specific change from the confirmed task(s);
    • why — the constraint or discovery that forced it;
    • what it affects — the plan item ref(s) involved (--task), any other task ids or coverage targets it touches (--affects), and which acceptance criteria are no longer accurate.
  3. Get explicit human approval. This is the one non-negotiable step. A deviation is not real until a human says yes to this specific departure — not a standing blanket permission, not an inference from silence.
  4. Record it via devague deviate. Once approved, record the deviation as a first-class ledger entry (never edit the plan itself — the plan stays the untouched historical contract; see devague/delivery.py). An --origin llm record lands proposed and still needs the user's --confirm — recording is not the same as approval landing as final.
  5. Adjust the affected task briefs. Update the working instructions the task agent(s) are building against so they reflect the approved departure, not the stale plan text.
  6. Resume. Only after the record exists (and, for an llm-origin record, only after it is confirmed) does the fan-out continue.

Deviations are never silently folded into drift after the fact — by the time /summarize-delivery runs, every departure from the plan already has a dN record with a reason, an approval, and an optional classification. The delivery summary quotes these records; it does not reconstruct drift from memory.

The shipped CLI surface

This skill invokes the CLI directly and stays self-contained (if devague isn't on your PATH: uv tool install devague). Deviation state persists under .devague/deliveries/<plan-slug>.json — a peer of the plan store, keyed by the plan slug, and never touches the plan JSON itself.

MoveWhat it does
devague deviate "<what>" --task <tN> --reason "<text>"Record a deviation against plan item <tN>. User-origin (the default) auto-approves.
devague deviate "<what>" --task <tN> --reason "<text>" --affects <ref> [<ref> ...]Same, also naming every other plan item ref or coverage target the deviation touches (repeatable).
devague deviate "<what>" --task <tN> --reason "<text>" --classification acceptable|risky|needs-follow-upSame, tagging the deviation with the classification the drift-entry contract consumes downstream.
devague deviate "<what>" --task <tN> --reason "<text>" --origin llmAn LLM-proposed record; lands proposed, not approved.
devague deviate --confirm <dN>User-only: approve a proposed deviation.
devague deviate --reject <dN>User-only: reject a proposed (or any) deviation.
devague deviate --list [--json]Read every recorded deviation back (also the default action with no positional/flag).
devague deviate ... --plan <slug>Target a plan other than the current one.

--reason is required on every record — omitting it is refused with a hint. --task naming the plan item ref is likewise required.

Show full SKILL.md (463 more words)Show less

Hard rules (do not violate)

  • Never record a deviation the human did not approve. devague deviate without --origin llm auto-approves the instant it is run — so a user-origin record IS the approval. Only run it after the human has said yes to this specific departure, never preemptively "to be safe."
  • Never continue past a refused approval. If the human does not approve, the run stays stopped on that task. Do not record the deviation anyway, do not quietly implement the diverging approach, and do not advance the wave.
  • LLM-origin records stay proposed until the user confirms. --origin llm lands proposed; only devague deviate --confirm <dN> (user-only) makes it approved. Same anti-fabrication contract as every other origin in the method — an agent's own proposal never self-confirms.
  • Deviations are never silently folded into drift after the fact. Every departure from the confirmed plan gets a dN record at the moment it happens — not reconstructed from memory when /summarize-delivery runs later.
  • The CLI stays non-orchestrating (issue #20). devague deviate records a decision the human already made; it does not spawn agents, gate merges, mark tasks done, or make the approval decision itself. Recording is deterministic — no LLM calls inside the CLI.
  • This is not a fourth standing gate. /assign-to-workforce's three human gates are the exported spec, the implementation split plan, and the final PR. /deviate does not add a fourth — it is the human owner of gate 2 amending the approved split for one scoped, in-flight decision.

Worked example

Mid-fan-out on task t4, the task agent discovers the acceptance criteria assumed a helper that task t2 never actually shipped:

bash
# 1. STOP — the main agent halts t4's worktree before more code lands
#    against a criterion that can't be met as written.

# 2. Present what/why/what-it-affects to the human:
#    what:    t4's acceptance criterion 2 assumes a `--json` flag on a
#             helper that t2 shipped without one
#    why:     t2's scope was cut to land its wave on time
#    affects: t4 (this task), and coverage target c9 (the criterion in
#             question)

# --- HUMAN: approves dropping the --json assumption from t4's criterion ---

# 3. Record the approved deviation
devague deviate "drop the --json assumption from t4's acceptance criterion" \
  --task t4 --reason "t2 shipped its helper without --json to land its wave on time" \
  --affects t2 --affects c9 --classification acceptable

# 4. Adjust t4's working brief to match what was approved, then resume the
#    task agent against the corrected instruction.

# Read the ledger back at any point:
devague deviate --list
devague deviate --list --json

If the agent had proposed the record itself (--origin llm), the same record would land proposed and need an explicit devague deviate --confirm d1 from the user before /summarize-delivery could cite it as approved.

After recording — resume, then hand off to /summarize-delivery

Once the affected task briefs are adjusted and the fan-out resumes, nothing further is needed from this skill — the record already lives in the delivery store. When the run reaches /summarize-delivery, that skill's Drift From Plan and Mid-work Decisions sections quote these records by their dN id instead of reconstructing drift from memory, so the connective tissue between the confirmed plan and the delivery summary is the ledger this skill wrote, not anyone's recollection of the run.

Provenance

This is a first-party skill — its origin is agentculture/devague, the sixth in the outbound family after /scope, /think, /spec-to-plan, /assign-to-workforce, and /summarize-delivery, covering the execution-time leg that runs inside an /assign-to-workforce fan-out. guildmaster pulls it from here and broadcasts it to the AgentCulture mesh; because devague is upstream, it is never re-vendored back from guildmaster's re-broadcast copy. The cite, don't import policy still holds: downstream repos copy it, they don't symlink or depend on it. See docs/skill-sources.md.

© agentculture, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/deviate of agentculture/culture.

Open the folder on GitHubat commit d5b5715

Compare with similar skills

Deviate next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Deviate compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Deviate this skillagentculture/culture113—~2.4kAutomated safety check: PassApache-2.0
Flightsasgeirtj/system_prompts_leaks69k—~2.1kAutomated safety check: PassCC0-1.0
Flightscodewhale-hq/Codewhale41k—~258Automated safety check: PassMIT
Verify and StopJuliusBrussee/caveman110k1 repos~176Automated safety check: PassApache-2.0
Stop Wordsthedaviddias/Front-End-Checklist74k—~521Automated safety check: PassMIT
GitHub Issue Bulk Assignercodewhale-hq/Codewhale41k—~953Automated safety check: PassMIT

Similar skills

  • Flights

    asgeirtj/system_prompts_leaks

    Research, book, or manage flights, including check-in. An agent skill from asgeirtj/system_prompts_leaks.

    69k GitHub stars~2.1k tokensUpdated today
    Auto-check passed

  • Flights

    codewhale-hq/Codewhale

    Track flights and look up status and schedules. An agent skill from codewhale-hq/Codewhale.

    41k GitHub stars~258 tokensUpdated today
    Auto-check passed

  • Verify and Stop

    JuliusBrussee/caveman

    Prove existing work meets acceptance conditions without expanding scope. Use for validation-only tasks, completion checks, focused gate runs, and last-mile…

    110k GitHub starsUsed in 1 repo~176 tokens
    Agent WorkflowsAuto-check passed

  • Stop Words

    thedaviddias/Front-End-Checklist

    A skill your agent uses when applies primarily when creating new content pages.

    74k GitHub stars~521 tokensUpdated yesterday
    Auto-check passed

  • GitHub Issue Bulk Assigner

    codewhale-hq/Codewhale

    Moves a list of GitHub issues into a milestone or assigns them to owners with the gh CLI, checking each one before and after the change.

    41k GitHub stars~953 tokensUpdated today
    DevelopmentAuto-check passed

  • Diagnose Why Work Stopped

    paperclipai/paperclip

    Diagnose stalled, looping, or over-recovered Paperclip issue trees and propose a no-code product-rule plan.

    99k GitHub stars~2.8k tokensUpdated today
    Auto-check passed

More from agentculture/culture

All 18 skills in this repo

  • Agent Config

    agentculture/culture

    Show a Culture agent's full configuration in one read-only view: its system-prompt file (CLAUDE.md / AGENTS.md / GEMINI.md), the parallel culture.yaml, and the agent's local .claude/skills index.

    113 GitHub stars~1k tokensUpdated 1 mo ago
    Auto-check passed

  • Cicd

    agentculture/culture

    CI/CD lane for culture: branch, commit, push, create PR, wait for automated reviewers, fetch comments, fix or pushback, reply, resolve threads.

    113 GitHub stars~3.7k tokensUpdated 1 mo ago
    Auto-check passed

  • Communicate

    agentculture/culture

    All agent communication from culture: in-mesh chat (channels, DMs, mentions, knowledge sharing) via culture channel CLI, AND cross-repo hand-off briefs to sibling-repo agents (agentirc, steward…

    113 GitHub stars~2.8k tokensUpdated 1 mo ago
    Auto-check passed

  • Communicate

    agentculture/culture

    Cross-repo + mesh communication: file tracked GitHub issues on sibling repos, comment on existing issues, fetch issues with body + comments to inline current state into briefs, and send live…

    113 GitHub stars~2.7k tokensUpdated 1 mo ago
    Auto-check passed

  • Assign To Workforce

    agentculture/culture

    Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent.

    113 GitHub stars~2.7k tokensUpdated 1 mo ago
    Auto-check: warnings

  • Pypi Maintainer

    agentculture/culture

    Switch a PyPI package install between the production index, TestPyPI pre-release builds, and a local editable checkout.

    113 GitHub stars~711 tokensUpdated 1 mo ago
    Auto-check passed

Questions about Deviate

What does Deviate do?

Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only…. Deviate is an agent skill from agentculture/culture. Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only deviation record via devague deviate before resuming — never fold a deviation silently into drift after the fact.

When should I use Deviate?

Deviate fits situations like: the user says deviate from the plan; we need to change the plan mid-run; record a deviation; this isnt matching the plan anymore.

How do I install Deviate in Claude Code?

Run `npx skills add agentculture/culture --skill deviate -a claude-code`. Or copy the skill folder (.claude/skills/deviate in agentculture/culture) into .claude/skills/deviate in your project. Claude Code loads it when a task matches its description.

How do I install Deviate in Codex?

Run `npx skills add agentculture/culture --skill deviate -a codex`. Or copy the skill folder (.claude/skills/deviate in agentculture/culture) into .agents/skills/deviate in your project. Codex loads it when a task matches its description.

Can I use Deviate in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add agentculture/culture --skill deviate -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/deviate, .gemini/skills/deviate, .github/skills/deviate and .opencode/skills/deviate in your project.

What does Deviate need to run?

Going by SKILL.md and its folder, Deviate needs the command-line tools its instructions call (uv).

Does Deviate access the network?

SKILL.md contains no URLs. Its commands use uv, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Deviate safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Deviate use?

Deviate is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Deviate use?

About 2.4k tokens (SKILL.md is roughly 9.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Deviate?

Skills that share tags, products or a category with Deviate: Flights (asgeirtj/system_prompts_leaks, 69k stars), Flights (codewhale-hq/Codewhale, 41k stars), Verify and Stop (JuliusBrussee/caveman, 110k stars) and Stop Words (thedaviddias/Front-End-Checklist, 74k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Deviate?

agentculture (a GitHub organization) maintains it in agentculture/culture, which has 113 GitHub stars. The repository holds 18 skills in this directory. The repository was last updated on August 23, 2026.

Source: agentculture/culture on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.