Apply locus of control — the design choice between making the system appear to act on the user's behalf (external locus) and making the user appear to direct the system (internal locus).

Apache-2.0Auto-check passed

Install Control Locus

skills CLI
$ npx skills add hashgraph-online/awesome-codex-plugins --skill control-locus -a claude-code

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

GitHub CLI
$ gh skill install hashgraph-online/awesome-codex-plugins control-locus --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/hashgraph-online/awesome-codex-plugins.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/HDeibler/universal-design-principles/plugins/interaction-and-control-principles/skills/control-locus .claude/skills/control-locus && 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
control-locus
GitHub stars
1.2k
Token cost
~3.2k tokens
SKILL.md length
1,839 words
Files
2 (incl. references)
Skills in repo
736
Repo updated
First seen
Licence
Apache-2.0

At a glance

Apply locus of control — the design choice between making the system appear to act on the user's behalf (external locus) and making the user appear to direct the system (internal locus).

  • Designing AI-assisted features
  • SKILL.md covers Why locus matters, When external locus is…, When internal locus is… and Designing for locus deliberately, plus 5 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Autocorrect/autocomplete behaviors

What it does

Control Locus is an agent skill from hashgraph-online/awesome-codex-plugins. Apply locus of control — the design choice between making the system appear to act on the user's behalf (external locus) and making the user appear to direct the system (internal locus). Use when designing AI-assisted features, autocorrect/autocomplete behaviors, recommendation surfaces, automated workflows, and any feature where the system could either do things automatically or wait for user instruction. Internal locus produces higher engagement, learning, and satisfaction; external locus produces higher…

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/automation-design.md`).

The repository describes itself as: A curated list of awesome OpenAI Codex / ChatGPT plugins, skills, and resources. The 1 Codex Marketplace. See live plugins at: https://hol.org/plugins/best-codex-plugins. The licence is Apache-2.0.

When your agent uses it

  • Designing AI-assisted features
  • Autocorrect/autocomplete behaviors
  • Recommendation surfaces
  • Automated workflows

Example prompts

  • “/control-locus”

What it can do on your machine

Read from SKILL.md and the folder at commit 16b4156. 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

    No scripts in the folder and no shell commands in SKILL.md.

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

  • Network

    No URLs in SKILL.md.

    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

Control Locus loads about 3.2k tokens when it runs, and up to ~5.3k if it reads all its reference files. Until then it costs about 157 tokens; SKILL.md has 1,839 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~157
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.3k

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 hashgraph-online/awesome-codex-plugins at commit 16b4156, republished under its Apache-2.0 licence (© hashgraph-online). 1,839 words, ~3,173 tokens.

Download SKILL.mdSave it as .claude/skills/control-locus/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
control-locus
description
Apply locus of control — the design choice between making the system appear to act on the user's behalf (external locus) and making the user appear to direct the system (internal locus). Use when designing AI-assisted features, autocorrect/autocomplete behaviors, recommendation surfaces, automated workflows, and any feature where the system could either do things automatically or wait for user instruction. Internal locus produces higher engagement, learning, and satisfaction; external locus produces higher convenience but lower agency. The skill is choosing deliberately and explaining the choice in the UI.

Control — locus

Locus of control is the perception of who is doing the doing. An internal locus of control means the user feels they are directing the system; an external locus means the user feels the system is directing them. Both can be useful depending on the task — but the choice has psychological consequences that often go unconsidered, especially in automated and AI-assisted features.

A well-designed system makes a deliberate choice about locus, usually shifting it depending on the task: internal for creative or judgment-intensive work, external for routine or expertise-deficient tasks. The same product can have different loci in different surfaces.

Why locus matters

The psychological evidence is consistent. Users with a stable internal locus of control — across life, not just in software — report higher motivation, persistence, and satisfaction. Users with a stable external locus tend toward passivity and learned helplessness. While these are stable personality traits, situational locus is malleable, and software design can push it in either direction.

A product that does things on the user's behalf without asking — autocorrects their typing, autocategorizes their email, auto-generates recommendations — moves the situational locus toward external. Useful in moderation, this becomes problematic when overdone: users feel the product is doing the work and they're just observing. They lose the sense of authorship over the output. They learn less about the underlying system. They have less to point to as their own.

A product that waits for explicit user direction — asks for confirmation before acting, presents options without picking one, requires the user to invoke each capability — moves the locus toward internal. Useful when the user has expertise and judgment, this becomes burdensome when overdone: users feel they're doing all the work and the product is just a passive instrument. They get tired. They make errors that the product could have prevented. They wonder why the product doesn't help more.

The right locus depends on the task and the user, and the choice deserves more attention than it usually gets.

When external locus is appropriate

External locus — the system acting on the user's behalf — is appropriate when:

The user lacks the expertise to make the choice well. Spell-check correcting a misspelled word. Photo software auto-correcting white balance. Email apps grouping conversations into threads. The user can't reliably make these decisions, and the system can. Letting the system act creates value that wouldn't exist otherwise.

The decision is routine and recurring. Auto-saving a document. Auto-syncing data. Auto-paying recurring bills. The user has already implicitly authorized the system to handle this category of task; making them confirm each instance would be exhausting.

The cost of error is low and recovery is easy. Auto-correcting a typo is fine if the user can immediately re-correct it. Auto-categorizing an expense is fine if it's easy to recategorize. The system can act first because the cost of being wrong is small.

The user explicitly delegated the task. "Set up auto-pay for this account" — the user has actively chosen to externalize the locus. The system is now expected to act without asking.

When internal locus is appropriate

Internal locus — the user directing the system — is appropriate when:

The user has expertise and the choice expresses their judgment. A musician choosing which take to keep. A photographer choosing the crop. A writer choosing the phrasing. These are the moments where the user's authorship is the entire point; the system should not pre-empt them.

The cost of error is high and recovery is hard. Sending a message to a customer. Deleting a database row. Moving money. The system should not act on the user's behalf for actions that, if wrong, would be expensive to undo. Internal locus here is not just psychological — it's protective.

The user is learning the system. A novice exploring a new tool benefits from seeing what each action does, building a mental model. A system that "helps" by doing things automatically prevents that learning from happening. Once expert, the user can tolerate (and welcome) more automation; while learning, more internal locus is better.

The decision is value-laden or contested. Recommendations that imply judgment ("you should buy this," "you should follow this person") are stronger when framed as suggestions the user is evaluating rather than as actions the system is taking. The user keeps the locus by deciding; the system supports the decision.

Designing for locus deliberately

The design choices that shift locus include:

Action without asking vs. suggestion with confirmation. "Auto-categorized as 'Travel'" with a small undo affordance vs. "Suggested category: Travel — confirm?" with options. The first is external locus, the second internal.

Showing what was done vs. asking what to do. "Removed 47 duplicate rows" vs. "We found 47 likely duplicate rows — review and remove?" Both useful in different contexts.

Defaults presented as suggestions vs. defaults presented as decisions. A form pre-filled with values the user can change conveys "we suggest these"; the same form pre-filled with values the user has to actively change conveys "we decided these for you." The design implementations may be similar, but the framing matters.

Visibility of automated actions. Actions performed automatically should be visible — at minimum in a log, ideally in the moment they happen. A hidden auto-action is the worst of both worlds: external locus, with no opportunity for the user to notice or learn.

Granularity of control over automation. Even when the system acts automatically, the user should be able to disable or tune the automation. A spell-checker the user can't turn off feels imposed; one with a clear settings panel feels delegated.

Worked examples

AI writing assistants

An AI writing tool can operate at different loci. A high-external version: the user types a single sentence and the AI writes the rest, presenting it for acceptance. A medium version: the AI suggests a continuation that the user can accept, modify, or reject. A high-internal version: the AI provides on-demand help (rewrite, summarize, brainstorm) only when explicitly invoked.

For users who want speed and don't care about authorship — a busy executive churning out routine emails — high external is fine. For users who care about voice and authorship — a writer working on a novel — high internal is essential. The same tool may need both modes for different users or different moments.

The failure mode: a writing tool that auto-completes aggressively for all users. Users who want the help benefit; users who care about authorship feel their voice being replaced and disengage. The fix is to make the locus a deliberate choice the user controls.

Show full SKILL.md (764 more words)Show less
Autocorrect on mobile keyboards

The classic external-locus feature, useful in most cases — typos are routine, recovery is easy, the user knows the correction is happening — and frustrating when wrong. The keyboard that learns the user's vocabulary and stops correcting their custom terms maintains a productive external locus; the keyboard that insists on correcting your friend's name to a common word every time produces the worst kind of automation surprise.

The lesson: external locus requires the system to be reliably right, or the user feels they're fighting an uncooperative tool.

Recommendation feeds

A social-media feed that shows recommended content interleaved with content from people you follow shifts locus toward external. Over time, users may feel they're consuming what the algorithm chooses rather than what they chose to follow. Some users like this (effort-free discovery); others resent it (loss of authorship over their attention).

A feed that shows only what the user followed and provides recommendations as a separate, clearly-labeled section maintains an internal locus. The user sees what they chose and explicitly visits the recommended section when they want.

Rule-based automations

Email rules ("when X arrives, do Y") are a high-internal-locus form of automation: the user wrote the rule, the user understands what will happen, the user can change or disable it. The locus is internal even though the system is acting automatically, because the user is the author of the action.

This is one of the cleanest patterns for combining automation with internal locus: the user delegates explicitly, with clear visibility into what will happen.

Confirmation dialogs

The classic mechanism for shifting locus toward internal at moments of high stakes. "Delete 47 files? This cannot be undone." The user pauses, decides, confirms. The locus stays internal because the user actively chose, even though the system did the deletion.

The failure mode: confirmation dialogs for everything, including low-stakes actions. The user starts clicking through them without reading, which puts them effectively in external locus (the dialog is now ignored noise) while still imposing the friction. Calibrate confirmation to actual stakes.

Anti-patterns

Hidden automation. The system does things on the user's behalf but doesn't show what or when. The user notices later that something changed and can't trace it back. This is the worst case: external locus with no transparency, eroding trust in the system. Always make automated actions visible.

Forced choice when the system has a confident answer. Asking the user to choose between "Delete this draft" and "Keep this draft" when an empty draft has obviously been abandoned. The system has the information to make the call; forcing the user to choose just adds friction. Move to external locus when you can do so accurately.

Internal-locus theater. Asking for the user's choice but presenting it in a way that funnels everyone to the same answer (a bright "Recommended" badge on one option, the other options small and gray). The locus appears internal but is actually external — the user's "choice" is the system's choice with extra steps. Either own the decision or actually present it as a real choice.

Automation that learns the wrong thing. A system that adapts to user behavior in ways the user can't see or control. The user trains the system inadvertently and is then surprised by what it does. Adaptive automation needs visibility into what the system has learned and easy ways to correct it.

Oscillating locus. A product that switches between automatic and manual behavior unpredictably ("usually it does X for you, but sometimes it asks"). Users can't form a stable mental model. Pick a locus per task and stick to it.

Heuristic checklist

For each automated or semi-automated feature, ask: What is the locus of control here, and is it appropriate to the user, the task, and the stakes? If the user lacks expertise and the stakes are low, external is probably right. If the user has expertise and the stakes are high, internal is probably right. Is the automation visible? If not, make it so. Can the user adjust or disable the automation? If not, build that affordance. Does the locus match across the surface? Inconsistent locus within a single product confuses users.

  • control — parent principle on the level of authority delegated to the user.
  • control-power-vs-simplicity — sibling skill on layering controls for mixed audiences.
  • forgiveness — undo and reversibility allow the system to operate at a more external locus safely.
  • feedback-loop — the mechanism by which automated actions become visible enough to maintain trust.
  • mental-model — stable locus supports a stable mental model; oscillating locus undermines it.

See also

  • references/automation-design.md — patterns for designing automation that maintains appropriate locus.

© hashgraph-online, 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

SKILL.md and 1 other file (references) in plugins/HDeibler/universal-design-principles/plugins/interaction-and-control-principles/skills/control-locus of hashgraph-online/awesome-codex-plugins.

  • SKILL.md
  • references/automation-design.md

Open the folder on GitHubat commit 16b4156

Compare with similar skills

Control Locus 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.

Control Locus compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Control Locus this skillhashgraph-online/awesome-codex-plugins1.2k—~3.2kAutomated safety check: PassApache-2.0
Audit Choicesdzhng/skills1k—~2.5kAutomated safety check: PassMIT
Chart Choicemohitagw15856/pm-claude-skills1.4k—~1.3kAutomated safety check: PassMIT
School Choice Decisionmohitagw15856/pm-claude-skills1.4k—~1.1kAutomated safety check: PassMIT
Locus Unity BridgeMisaka-Mikoto-Tech/agent-skills275—~4kAutomated safety check: PassMIT
Grad Public Choiceasgard-ai-platform/skills241—~1.7kAutomated safety check: PassMIT

Similar skills

  • Audit Choices

    dzhng/skills

    Audit the choices an implementing agent made, not its diff — a pure decision audit that traces the session's history into a choices ledger, changes no code, and never blocks an unsupervised run.

    1k GitHub stars~2.5k tokensUpdated 2 days ago
    Agent WorkflowsAuto-check passed
  • Chart Choice

    mohitagw15856/pm-claude-skills

    Pick the chart the data and the point actually need — the question-to-chart mapping (comparison, trend, composition, distribution, relationship), the honesty rules (axes, baselines, dual-axis…

    1.4k GitHub stars~1.3k tokensUpdated yesterday
    Frontend & DesignAuto-check passed
  • School Choice Decision

    mohitagw15856/pm-claude-skills

    Choose the right school for a specific child by weighing what actually matters to them and your family — not just rankings.

    1.4k GitHub stars~1.1k tokensUpdated yesterday
    Auto-check passed
  • Locus Unity Bridge

    Misaka-Mikoto-Tech/agent-skills

    A skill your agent uses when an agent needs to inspect or control a real Unity Editor through Locus, especially when Unity MCP is unavailable, named-pipe discovery is needed, C must be executed, or…

    275 GitHub stars~4k tokensUpdated 16 days ago
    Game DevelopmentAuto-check passed
  • Grad Public Choice

    asgard-ai-platform/skills

    Apply public choice theory to analyze political decision-making as rational self-interested behavior.

    241 GitHub stars~1.7k tokensUpdated 4 mo ago
    Auto-check passed
  • Choice Semantics

    PlamenTSV/plamen

    Trigger Pattern Always required for DAML audits - Inject Into Breadth agents, depth-state-trace, depth-edge-case

    303 GitHub stars~1.5k tokensUpdated 11 days ago
    Auto-check passed

More from hashgraph-online/awesome-codex-plugins

All 736 skills in this repo
  • Anime Reaction Gif

    hashgraph-online/awesome-codex-plugins

    Create original anime-style reaction stickers as looping GIFs and MP4 previews, using generated character pose sheets and timed key poses.

    1.2k GitHub stars~922 tokensUpdated yesterday
    Auto-check passed
  • Calibredb

    hashgraph-online/awesome-codex-plugins

    Manage and query Calibre libraries with the calibredb CLI (local paths or Calibre Content server URLs).

    1.2k GitHub stars~1k tokensUpdated yesterday
    Auto-check passed
  • Rust API Test Harness

    hashgraph-online/awesome-codex-plugins

    A skill your agent uses when adding, changing, testing, or debugging Rust HTTP APIs and services, especially when Codex needs black-box integration tests, random-port app startup, real database test…

    1.2k GitHub stars~1.7k tokensUpdated yesterday
    Auto-check passed
  • Art

    hashgraph-online/awesome-codex-plugins

    Make a studio's game look like something at build time — a cover from a real frame of the game (free), painted covers, backdrops, textures and character plates from image models through the…

    1.2k GitHub stars~2.4k tokensUpdated yesterday
    Auto-check passed
  • Calle

    hashgraph-online/awesome-codex-plugins

    Use CALL-E from Codex through the calle CLI. An agent skill from hashgraph-online/awesome-codex-plugins.

    1.2k GitHub stars~2.9k tokensUpdated yesterday
    Auto-check passed
  • Game Balance Economy

    hashgraph-online/awesome-codex-plugins

    Balance game difficulty, resources, rewards, probability, progression, economies, and dominant strategies.

    1.2k GitHub stars~618 tokensUpdated yesterday
    Auto-check passed

Questions about Control Locus

What does Control Locus do?

Apply locus of control — the design choice between making the system appear to act on the user's behalf (external locus) and making the user appear to direct the system (internal locus). Control Locus is an agent skill from hashgraph-online/awesome-codex-plugins. Apply locus of control — the design choice between making the system appear to act on the user's behalf (external locus) and making the user appear to direct the system (internal locus).

When should I use Control Locus?

Control Locus fits situations like: designing AI-assisted features; autocorrect/autocomplete behaviors; recommendation surfaces; automated workflows.

How do I install Control Locus in Claude Code?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill control-locus -a claude-code`. Or copy the skill folder (plugins/HDeibler/universal-design-principles/plugins/interaction-and-control-principles/skills/control-locus in hashgraph-online/awesome-codex-plugins) into .claude/skills/control-locus in your project. Claude Code loads it when a task matches its description.

How do I install Control Locus in Codex?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill control-locus -a codex`. Or copy the skill folder (plugins/HDeibler/universal-design-principles/plugins/interaction-and-control-principles/skills/control-locus in hashgraph-online/awesome-codex-plugins) into .agents/skills/control-locus in your project. Codex loads it when a task matches its description.

Can I use Control Locus 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 hashgraph-online/awesome-codex-plugins --skill control-locus -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/control-locus, .gemini/skills/control-locus, .github/skills/control-locus and .opencode/skills/control-locus in your project.

What does Control Locus need to run?

SKILL.md names no scripts, command-line tools or credentials: Control Locus is instructions for the agent only.

Does Control Locus access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Control Locus 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 Control Locus use?

Control Locus 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 Control Locus use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.1k tokens, read only when the agent opens those files.

What are the alternatives to Control Locus?

Skills that share tags, products or a category with Control Locus: Audit Choices (dzhng/skills, 1k stars), Chart Choice (mohitagw15856/pm-claude-skills, 1.4k stars), School Choice Decision (mohitagw15856/pm-claude-skills, 1.4k stars) and Locus Unity Bridge (Misaka-Mikoto-Tech/agent-skills, 275 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Control Locus?

hashgraph-online (a GitHub organization) maintains it in hashgraph-online/awesome-codex-plugins, which has 1,232 GitHub stars. The repository holds 736 skills in this directory. The repository was last updated on October 6, 2026.

Source: hashgraph-online/awesome-codex-plugins on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.