/position — load a team position into the session
is the generic teammate-bootstrap skill. It loads a position profile from
ai-workspace/team/<name>.md
and runs the bootstrap sequence the profile defines. Replaces the bespoke
(which, where present, is a thin wrapper around
that adds a unidirectional refusal contract — see "Wrapper skills" below).
Position vs role
- Position = persistent identity, loaded once per teammate session. Lives in
ai-workspace/team/<name>.md
- Role = one-shot activity dispatched at a step. Lives in
ai-workspace/agents/<name>.md
operates on positions only. For one-shot role dispatch, use your tool's subagent-dispatch mechanism — Claude Code:
Agent({subagent_type: <role-name>})
; Codex/Cursor: see your project's
§Agent Roles for the equivalent dispatch pattern.
1. Resolve position
bash
NAME="<arg>"
PROFILE="ai-workspace/team/${NAME}.md"
STATE_DIR="ai-workspace/team/${NAME}"
Pre-flight: if
does not exist, refuse with:
Position
not found at
ai-workspace/team/<name>.md
. Available positions: list them by running
ls ai-workspace/team/*.md
. (For one-shot subagent role dispatch instead, use your tool's role-dispatch mechanism — Claude Code:
Agent({subagent_type: <role>})
.)
Do not auto-bootstrap. Absence is a signal to verify the environment.
2. Load profile + state
Read in order. Load all files into context first, then reason — do not summarize as you read.
- (required) — the position's role identity, working agreement, decision rules, triggers, anti-patterns, lifecycle hooks.
- (if exists) — the position's operating manual.
${STATE_DIR}/DECISIONS.md
Most positions have NO sibling state directory — only stateful positions (currently just
) do. The skill silently skips state-load when the directory is absent.
3. Regenerate live state (if profile prescribes it)
The position's profile body specifies whether/how to regenerate live state on session start. Common patterns:
- TPM: + +
- Software-engineer: tail chat + read if resuming
- Technical-editor: tail chat for review requests
Follow the profile's
## Session lifecycle / Session start
section verbatim. The skill doesn't prescribe regeneration steps — the profile owns them.
4. Acknowledge + take the position
After load + bootstrap:
- Acknowledge:
Position '<name>' loaded. Following profile session-start instructions.
- Hold the position for the rest of the session — the agent operates as according to profile rules until session end.
- Chat handle (if the position's chat substrate is online): post the registration message the profile prescribes.
5. flag (optional)
/position <name> --resume
signals resumption of an interrupted session:
- Read if present (per the position's profile resume convention)
- Skip the registration chat post (the position is presumed already known to the team)
- Pick up where the prior session left off
If the profile has no resume semantics,
is a no-op silently.
6. Switching positions
A session can switch positions by re-invoking
. Latest wins. Profile rules from the prior position drop.
Exception: the
position has a unidirectional refusal contract (enforced by the
wrapper skill, where installed) — switching out of TPM mid-session is refused per its own rules.
Anti-patterns
| Anti-pattern | Why wrong |
|---|
| Reading from for | That's the role directory (subagents). Positions live in . |
| Auto-bootstrapping a missing position | Refusal is the contract — positions must be defined first |
| Soft-loading just the profile without the state dir | Stateful positions need both; skipping state breaks continuity |
| Summarizing the profile as you load it | Load first, reason second — same as v0 contract |
Treating /position <subagent-role>
| Roles are not positions; refuse and direct to your tool's role-dispatch mechanism (Claude Code: Agent({subagent_type: <role>})
|
Invocation forms
- — load position, run bootstrap
/position <name> --resume
Wrapper skills
A position can ship with a sibling
wrapper skill that adds position-specific lifecycle behavior on top of
. Wrappers are optional —
always works directly. If a wrapper is installed alongside
in the same skills repo, prefer the wrapper for the position it covers (it handles position-specific contracts the generic loader can't).
Example:
(where shipped as a separate skill) is the wrapper for the
position — it invokes
and adds a unidirectional refusal contract. If
is not installed in your environment, use
directly; the position loads cleanly without the wrapper, just without the refusal-contract enforcement.
Quick reference
| Step | Action | On failure |
|---|
| 1 | Resolve | Refuse with available positions list |
| 2 | Read profile + state dir | Silently skip state if dir absent |
| 3 | Regenerate live state per profile | — |
| 4 | Acknowledge + hold position | — |
| 5 | Honor if present | No-op if profile has no resume semantics |
| 6 | Switch positions on re-invoke | Refuse for unidirectional positions (tpm) |