Agent skill

Skill Intent Contract

by nyldn in nyldn/claude-octopus

A skill your agent uses when starting a complex or ambiguous task that risks scope drift

MITAuto-check passed

Install Skill Intent Contract

skills CLI
$ npx skills add nyldn/claude-octopus --skill skill-intent-contract -a claude-code

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

GitHub CLI
$ gh skill install nyldn/claude-octopus skill-intent-contract --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/nyldn/claude-octopus.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/skill-intent-contract .claude/skills/skill-intent-contract && 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
skill-intent-contract
GitHub stars
4.2k
Used in
1 other repo
Token cost
~3.8k tokens
SKILL.md length
1,141 words
Files
2
Skills in repo
62
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when starting a complex or ambiguous task that risks scope drift

  • Works in 6 steps: Allocate the work before scoping it → Capture Intent → Write Intent Contract File → …
  • Starting a complex
  • SKILL.md covers Purpose, Intent Contract Structure, Implementation Instructions and Integration with Workflows, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Skill Intent Contract is an agent skill from nyldn/claude-octopus. Use when starting a complex or ambiguous task that risks scope drift

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `agents/openai.yaml`).

The repository describes itself as: Run multiple AI models against the same research, design, or coding task. Surface disagreements before you ship. The licence is MIT.

When your agent uses it

  • Starting a complex
  • Ambiguous task that risks scope drift

Example prompts

  • “/skill-intent-contract”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Allocate the work before scoping it
  2. Capture Intent
  3. Write Intent Contract File
  4. Reference During Execution
  5. Validate at End
  6. Update Intent Contract Status

What it can do on your machine

Read from SKILL.md and the folder at commit 4d152db. 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 (its code samples are markdown, javascript and bash).

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

  • Network

    Links to these hosts (documentation or services it may open):

    • arxiv.org

    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

Skill Intent Contract loads about 3.8k tokens when it runs. Until then it costs about 23 tokens; SKILL.md has 1,141 words of instructions outside code blocks.

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

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 nyldn/claude-octopus at commit 4d152db, republished under its MIT licence (© nyldn). 1,141 words, ~3,816 tokens.

Download SKILL.mdSave it as .claude/skills/skill-intent-contract/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
skill-intent-contract
description
Use when starting a complex or ambiguous task that risks scope drift
disable-model-invocation
true

Host: Codex CLI — This skill was designed for Claude Code and adapted for Codex. Cross-reference commands use installed skill names in Codex rather than /octo:* slash commands. Use the active Codex shell and subagent tools. Do not claim a provider, model, or host subagent is available until the current session exposes it. For host tool equivalents, see skills/blocks/codex-host-adapter.md.

Intent Contract System

Purpose

The intent contract creates a persistent record of user intent that:

  • Captures what the user is trying to accomplish
  • Defines success criteria upfront
  • Establishes boundaries and constraints
  • Travels through the entire workflow
  • Validates final outputs against original intent

This closes the loop between intention and delivery.

Intent Contract Structure

The intent contract is stored in the current resolved plan run directory as session-intent.md. Use scripts/plan-storage.sh to create or recover that directory; never write a loose intent file into .claude/.

markdown
# Intent Contract

**Created**: [ISO timestamp]
**Workflow**: [discover/embrace/review/etc.]
**Status**: [active/validating/completed]

## Job Statement
What the user is trying to accomplish (JTBD framework).

[User's goal in plain language]

## Success Criteria

### Good Enough
- [Minimum viable success criterion 1]
- [Minimum viable success criterion 2]

### Exceptional
- [Excellence criterion 1]
- [Excellence criterion 2]

## Boundaries
What this should NOT be:
- [Boundary 1: What to avoid]
- [Boundary 2: What's out of scope]

## Context & Constraints

**Stakeholders**: [Who needs this to work for them]
**Existing Assets**: [What to build on]
**Timeline**: [Time constraints if any]
**Technical Constraints**: [Platform, language, dependencies]

## Clarifying Context
[Any answers from the 3-question pattern]

## Task Allocation
**Risk**: [low | intermediate | high]
**Initiative**: [human | AI | shared] — who starts and proposes
**Control**: [human | AI | shared] — who oversees execution as it runs
**Decision rights**: [human | AI] — who has final say on the outcome
**AI role**: [none | executor | collaborator | challenger]
**Execution disposition**: [AI-assisted | human-only | pending-user-decision]
**Escalation decision**: [not-needed | pending | user's recorded resolution]
**Resolved AUTONOMY_MODE**: [supervised | semi-autonomous | loop-until-approved | autonomous | not-applicable (contract-only sentinel)]

## Validation Checklist
- [ ] Meets "good enough" criteria
- [ ] Respects all boundaries
- [ ] Works for all stakeholders
- [ ] Builds on existing assets appropriately
- [ ] Allocation still fits what the task turned out to be

Implementation Instructions

When to Create Intent Contract

Create an intent contract when:

  • User invokes a major workflow (/octo:embrace, /octo:discover, /octo:plan)
  • User explicitly asks to "plan" or "set goals" for a task
  • A workflow requires multiple phases and validation

Do NOT create for:

  • Quick, single-action commands
  • Simple file reads or searches
  • Conversational questions
Step 0: Allocate the work before scoping it

Run this before capturing intent. The question is not how to run the task across agents but whether it should be delegated at all, and if so, which parts of the authority go where. Framework: Afroogh, Varshney & D'Cruz (2025), A Task-Driven Human-AI Collaboration (arXiv:2505.18422).

Classify risk. Complexity is already scored elsewhere — defer to estimate_complexity and classify_cynefin in scripts/lib/routing.sh rather than re-deriving it. Risk is a separate axis that nothing in the codebase measures, so judge it here on three questions:

  • Irreversibility — can the effect be undone, and at what cost?
  • Consequence — is anything material at stake: safety, money, data, users?
  • Accountability — is a specific person expected to answer for the outcome?
RiskReading
LowReversible, no material consequence, no named accountability.
IntermediateReversible only at real cost, or consequence is unclear.
HighIrreversible, materially consequential, or someone must answer for it.

Allocate the three dimensions separately. They are independent, and treating them as one axis is the mistake this step exists to prevent. People readily hand AI the initiative on unfamiliar work while keeping control and decision rights — an allocation a single autonomy slider cannot express.

  • Initiative — who starts, proposes, drafts.
  • Control — who oversees execution while it runs.
  • Decision rights — who has final say on the result.

Record every outcome explicitly:

Risk / complexityInitiativeControlDecision rightsAI roleExecution dispositionEscalation decisionMode
Low / lowAIAIAIexecutorAI-assistednot-neededautonomous
Low / highsharedhumanhumancollaboratorAI-assistednot-neededloop-until-approved
High / lowhumanhumanhumanexecutorAI-assistednot-neededsupervised
High / highhumanhumanhumanchallengerAI-assistednot-neededsupervised

The High / high allocation is adversarial: the human leads while AI attacks the proposed decision as a deliberate counterweight to the human's own bias. In High / low work, AI may execute only the bounded actions the human directly approves.

The rule that inverts. For intermediate-risk work where uncertainty is highest, the cited evidence says avoid AI entirely — "neither as a gatekeeper nor as a second opinion". This contradicts the smooth intuition that middling risk implies middling involvement, and it also sits in tension with the same paper's broader claim that complete human autonomy is rarely justified. That tension is real and unresolved; surface it to the user and let them decide rather than quietly picking a side.

Resolve to a setting. The workflow engine reads one variable, AUTONOMY_MODE, with four values:

AllocationAUTONOMY_MODE
Human holds control and decision rights, approving each phasesupervised
AI runs; human is pulled in on failures and quality gatessemi-autonomous
AI runs and iterates; human holds final decision rightsloop-until-approved
AI holds all threeautonomous

Record the three dimensions and the resolved mode. The mapping is lossy: one axis cannot represent three independent allocations, so a contract that stores only the mode loses the reason it was chosen. That record is what a later reviewer needs when the allocation turns out to have been wrong.

not-applicable is a persisted, contract-only sentinel for human-only work; it is not a fifth runtime value and must not be passed to the workflow engine.

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

For intermediate risk, record Execution disposition: pending-user-decision. Record Escalation decision: pending, then stop before execution. Ask the user to choose human-only handling or a specific documented AI allocation. Record their answer, rewrite the Task Allocation fields to match it, and change Escalation decision to the user's resolution before continuing. For a human-only resolution, record AI role: none and Resolved AUTONOMY_MODE: not-applicable; human-only not-applicable must not be passed to the workflow engine. Resolve to the supported human-only behavior and do not execute AI work in that state.

For a documented AI-assisted resolution, record every Task Allocation field:

  • Initiative, Control, Decision rights, and AI role from the chosen allocation
  • Execution disposition: AI-assisted
  • Escalation decision: user's recorded resolution
  • Resolved AUTONOMY_MODE: exactly one of supervised, semi-autonomous, loop-until-approved, or autonomous, mapped using the table above

Validate the selected runtime mode and only then execute. The runtime must reject not-applicable and every unknown or unsupported mode before workflow execution rather than defaulting to autonomous behavior.

Step 1: Capture Intent

After asking the 3 clarifying questions in a workflow, prompt the user to define:

javascript
AskUserQuestion({
  questions: [
    {
      question: "What are you ultimately trying to accomplish?",
      header: "Goal",
      multiSelect: false,
      options: [
        {label: "Let me describe it", description: "I'll write my own goal statement"},
        {label: "Make a decision", description: "Choose between options"},
        {label: "Create deliverable", description: "Build something specific"},
        {label: "Understand a problem", description: "Research and learn"}
      ]
    },
    {
      question: "What defines success for this?",
      header: "Success",
      multiSelect: true,
      options: [
        {label: "Clear recommendation", description: "Know what to do next"},
        {label: "Working implementation", description: "Code that functions"},
        {label: "Team alignment", description: "Everyone understands"},
        {label: "Problem solved", description: "Issue is resolved"}
      ]
    },
    {
      question: "What should this NOT be or do?",
      header: "Boundaries",
      multiSelect: true,
      options: [
        {label: "Over-engineered", description: "Keep it simple"},
        {label: "Incomplete", description: "Must be production-ready"},
        {label: "Disconnected", description: "Must fit our architecture"},
        {label: "Risky", description: "Avoid experimental approaches"}
      ]
    }
  ]
})

If user selects "Let me describe it", follow up with a text prompt for their custom goal.

Step 2: Write Intent Contract File

Resolve a unique run directory, then use the Write tool to create its session-intent.md:

bash
PLAN_STORAGE="${CLAUDE_PLUGIN_ROOT:-${HOME}/.claude-octopus/plugin}/scripts/plan-storage.sh"
OCTO_PLAN_DIR="$("$PLAN_STORAGE" current "$PWD" 2>/dev/null || "$PLAN_STORAGE" create "$PWD")"
cat > "${OCTO_PLAN_DIR}/session-intent.md" <<EOF
# Intent Contract

**Created**: $(date -u +"%Y-%m-%dT%H:%M:%SZ")
**Workflow**: ${WORKFLOW_NAME}
**Status**: active

## Job Statement
${USER_GOAL}

## Success Criteria

### Good Enough
${MIN_SUCCESS_CRITERIA}

### Exceptional
${EXCEPTIONAL_CRITERIA}

## Boundaries
What this should NOT be:
${BOUNDARIES}

## Context & Constraints

**Stakeholders**: ${STAKEHOLDERS}
**Timeline**: ${TIMELINE}

## Clarifying Context
${THREE_QUESTION_ANSWERS}

## Validation Checklist
- [ ] Meets "good enough" criteria
- [ ] Respects all boundaries
- [ ] Works for all stakeholders
EOF
Step 3: Reference During Execution

Throughout the workflow, recover the current plan directory with plan-storage.sh current "$PWD" and periodically read its session-intent.md to:

  • Stay aligned with user goals
  • Make decisions consistent with boundaries
  • Keep stakeholders in mind

At key decision points, explicitly say:

Checking against intent contract: [reference specific criterion]
Step 4: Validate at End

When the workflow completes, read the resolved plan directory's session-intent.md and validate:

Validation Process:

  1. Read the intent contract

  2. Check each success criterion:

    • ✓ Met - explain how
    • ✗ Not met - explain why and what's needed
    • ~ Partially met - explain gaps
  3. Check boundaries:

    • ✓ Respected - confirm
    • ✗ Violated - explain what happened
  4. Generate validation report:

markdown
# Validation Report

## Success Criteria Check

### Good Enough Criteria
- [✓] Criterion 1: [How it was met]
- [✗] Criterion 2: [Why not met, what's needed]

### Exceptional Criteria
- [~] Criterion 1: [Partial progress explanation]

## Boundary Check
All boundaries respected: [Yes/No]
- Boundary 1: [✓/✗] [Explanation]

## Gaps & Next Steps
[If any criteria not met, list concrete next steps]

## Overall Assessment
[Summary: Does this fulfill the original intent?]
  1. Present to user:
    • Show the validation report
    • Ask if they want to address any gaps
    • Update intent contract status to "completed" or "validating"
Step 5: Update Intent Contract Status

Update the Status field in the resolved plan directory's session-intent.md:

  • active → workflow in progress
  • validating → checking against criteria
  • completed → all criteria met, boundaries respected
  • incomplete → some criteria not met, gaps identified

Integration with Workflows

Embrace Workflow
1. Ask 3 clarifying questions (scope, focus, autonomy)
2. Create intent contract
3. DISCOVER phase (reference intent)
4. DEFINE phase (reference intent)
5. DEVELOP phase (reference intent)
6. DELIVER phase (reference intent)
7. Validate against intent contract
8. Present validation report
Discover Workflow
1. Ask 3 clarifying questions (depth, focus, output)
2. Create intent contract
3. Execute multi-provider research
4. Synthesize findings
5. Validate against intent contract
6. Present validation report
Plan Workflow (Future)
1. Capture comprehensive intent
2. Create intent contract
3. Route to appropriate workflows
4. Execute custom sequence
5. Validate against intent contract
6. Present validation report

Example Intent Contract

markdown
# Intent Contract

**Created**: 2026-01-21T15:30:00Z
**Workflow**: embrace
**Status**: active

## Job Statement
Build a user authentication system that our team can implement and maintain.

## Success Criteria

### Good Enough
- Team understands what to build
- Clear technical approach selected
- Security considerations documented
- Implementation plan with steps

### Exceptional
- Multiple authentication methods evaluated
- Security audit performed
- Code examples provided
- Integration tests included

## Boundaries
What this should NOT be:
- Over-engineered with unnecessary features
- Disconnected from our existing Node.js/Express stack
- Experimental or unproven technologies

## Context & Constraints

**Stakeholders**: Development team (5 engineers), Product manager
**Existing Assets**: Express.js API, PostgreSQL database
**Timeline**: Need to start implementation next sprint
**Technical Constraints**: Must work with Express.js, PostgreSQL

## Clarifying Context

**Scope**: Medium feature (multiple components)
**Focus Areas**: Security, Architecture design
**Autonomy**: Supervised (review after each phase)

## Validation Checklist
- [ ] Meets "good enough" criteria
- [ ] Respects all boundaries
- [ ] Works for all stakeholders
- [ ] Builds on existing assets appropriately

Benefits

For Users:

  • Clear expectations set upfront
  • No forgotten requirements
  • Validation against original goals
  • Closed-loop accountability

For Workflows:

  • Clear success criteria to optimize for
  • Boundaries to constrain solutions
  • Context for better decisions
  • Validation framework built-in

Ready to use! Workflows can now create and validate against persistent intent contracts.

© nyldn, MIT. 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 in skills/skill-intent-contract of nyldn/claude-octopus.

  • SKILL.md
  • agents/openai.yaml

Open the folder on GitHubat commit 4d152db

Used in 1 other repository

We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in nyldn/claude-octopus, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Skill Intent Contract 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.

Skill Intent Contract compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Skill Intent Contract this skillnyldn/claude-octopus4.2k1 repos~3.8kAutomated safety check: PassMIT
StartDonchitos/Claude-Code-Game-Studios26k—~6.4kAutomated safety check: PassMIT
Intent Requirements IntakeYeachan-Heo/oh-my-claudecode40k—~1.5kAutomated safety check: PassMIT
Intent Driven Developmentaffaan-m/ECC275k1 repos~4.3kAutomated safety check: PassMIT
Riskalsk1992/CloddsBot2.9k1 repos~2.4kAutomated safety check: PassMIT
Trader Riskruvnet/ruflo74k1 repos~358Automated safety check: NotesMIT

Similar skills

  • Start

    Donchitos/Claude-Code-Game-Studios

    First-time onboarding — asks where you are, then guides you to the right workflow.

    26k GitHub stars~6.4k tokensUpdated 9 days ago
    Game DevelopmentAuto-check passed
  • Intent Requirements Intake

    Yeachan-Heo/oh-my-claudecode

    Turns a pasted chat log or spoken problem report from support or ops staff into a reviewed five-section intent.md through numbered batches of questions.

    40k GitHub stars~1.5k tokensUpdated yesterday
    Product & Project ManagementAuto-check passed
  • Turn ambiguous or high-impact product and engineering changes into scoped, verifiable acceptance criteria before or alongside implementation.

    275k GitHub starsUsed in 1 repo~4.3k tokens
    DevelopmentAuto-check passed
  • Risk

    alsk1992/CloddsBot

    Unified risk engine with VaR, stress testing, volatility regimes, and automated controls

    2.9k GitHub starsUsed in 1 repo~2.4k tokens
    Testing & QAAuto-check passed
  • Trader Risk

    ruvnet/ruflo

    Assess portfolio risk using npx neural-trader — VaR, CVaR, Sharpe, position sizing, circuit breaker status

    74k GitHub starsUsed in 1 repo~358 tokens
    Auto-check: notes
  • Browser Intent

    ruvnet/ruflo

    Execute a natural-language browser intent via page-agent (browseract) when the target is easier to describe than to select — degrades gracefully when page-agent or an OpenAI-compatible LLM provider…

    74k GitHub stars~1.2k tokensUpdated today
    Productivity & AutomationAuto-check: notes

More from nyldn/claude-octopus

All 62 skills in this repo
  • Octopus Quick

    nyldn/claude-octopus

    Quick execution for ad-hoc tasks without full workflow overhead — use for small, self-contained requests

    4.2k GitHub starsUsed in 1 repo~2.2k tokens
    Auto-check passed
  • Octopus Research

    nyldn/claude-octopus

    Thorough research across multiple sources — use for complex topics needing broad synthesis

    4.2k GitHub starsUsed in 1 repo~1.9k tokens
    Auto-check passed
  • Octopus Security Audit

    nyldn/claude-octopus

    OWASP compliance, vulnerability scanning, and adversarial red team testing — use for security reviews

    4.2k GitHub starsUsed in 1 repo~2.3k tokens
    Auto-check passed
  • Skill Audit

    nyldn/claude-octopus

    Audit codebases for quality, consistency, and broken patterns — use for pre-release or tech debt review

    4.2k GitHub starsUsed in 1 repo~3.2k tokens
    Auto-check passed
  • Skill Content Pipeline

    nyldn/claude-octopus

    Extract patterns and anatomy from URLs — use to reverse-engineer content strategies from live pages

    4.2k GitHub starsUsed in 1 repo~3.9k tokens
    Auto-check passed
  • Skill Context Detection

    nyldn/claude-octopus

    Auto-detect work context (Dev vs Knowledge) — use to tailor workflows based on current task type

    4.2k GitHub starsUsed in 1 repo~2.6k tokens
    Auto-check passed

Questions about Skill Intent Contract

What does Skill Intent Contract do?

A skill your agent uses when starting a complex or ambiguous task that risks scope drift. Skill Intent Contract is an agent skill from nyldn/claude-octopus.

When should I use Skill Intent Contract?

Skill Intent Contract fits situations like: starting a complex; ambiguous task that risks scope drift.

How do I install Skill Intent Contract in Claude Code?

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

How do I install Skill Intent Contract in Codex?

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

Can I use Skill Intent Contract 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 nyldn/claude-octopus --skill skill-intent-contract -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/skill-intent-contract, .gemini/skills/skill-intent-contract, .github/skills/skill-intent-contract and .opencode/skills/skill-intent-contract in your project.

What does Skill Intent Contract need to run?

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

Does Skill Intent Contract access the network?

SKILL.md names 1 domain. As links in the text: arxiv.org. This is read from the text; nothing was executed.

Is Skill Intent Contract 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 Skill Intent Contract use?

Skill Intent Contract is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Skill Intent Contract use?

About 3.8k tokens (SKILL.md is roughly 15k 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 Skill Intent Contract?

Skills that share tags, products or a category with Skill Intent Contract: Start (Donchitos/Claude-Code-Game-Studios, 26k stars), Intent Requirements Intake (Yeachan-Heo/oh-my-claudecode, 40k stars), Intent Driven Development (affaan-m/ECC, 275k stars) and Risk (alsk1992/CloddsBot, 2.9k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Skill Intent Contract?

nyldn (a GitHub user) maintains it in nyldn/claude-octopus, which has 4,182 GitHub stars. The repository holds 62 skills in this directory. The repository was last updated on October 7, 2026.

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