This skill turns implicit intent into an explicit, trackable artifact at the moment execution starts. It creates a lightweight intent contract, watches for scope drift while work is in progress, and closes each intent with a short resolution record.

Scope (Important)

Use this skill for coding tasks only. It is designed for implementation work that changes executable code.

Do not use it for general-agent activities such as:

broad research
planning-only conversations
documentation-only work
operational/admin tasks with no coding implementation

For trivial edits (for example, simple renames or typo fixes), skip the full intent frame.

Trigger

Activate at the planning-to-execution transition for non-trivial coding work.

Common cues:

User says: "go ahead", "implement this", "let's start building"
Agent is about to move from discussion into code changes

Workflow

Phase 1: Intent Capture

At execution start, emit:

## Intent Frame #N

**Outcome:** [One sentence. What does done look like?]
**Approach:** [How we will implement it. Key decisions.]
**Constraints:** [Out-of-scope boundaries.]
**Success criteria:** [How we verify completion.]
**Estimated complexity:** [Small / Medium / Large]

Rules:

Keep each field to 1-2 sentences.
Ask for confirmation before coding:
- Does this capture what we are doing? Anything to adjust before I start?
Do not proceed until the user confirms or adjusts.

Phase 2: Intent Monitor

During execution, monitor for drift at natural boundaries:

before touching a new area/file
before starting a new logical work unit
when current action feels tangential

Drift examples:

work outside stated scope
approach changes with no explicit pivot
new features/refactors outside constraints
solving a different problem than the stated outcome

When detected, emit:

## Intent Check #N

This looks like it may be moving outside the stated intent.

**Stated outcome:** [From active frame]
**Current action:** [What is happening]
**Question:** Is this a deliberate pivot or accidental scope creep?

If pivot is intentional, update the active intent frame and continue. If not, return to the original scope.

Phase 3: Intent Resolution

When work under the active intent ends, emit:

## Intent Resolution #N

**Outcome:** [Fulfilled / Partially fulfilled / Pivoted / Abandoned]
**What was delivered:** [Brief actual output]
**Pivots:** [Any acknowledged changes, or None]
**Open items:** [Remaining in-scope items, or None]

Resolution is preferred but optional if the session ends abruptly.

Multi-Intent Sessions

One session can contain multiple intent frames.

Rules:

Resolve current intent before opening the next.
If user changes direction mid-task, resolve current intent as Abandoned or Pivoted, then open a new frame.
Drift checks always target the currently active frame.
Number frames sequentially within the session (#1, #2, ...).
Constraints do not carry forward unless explicitly restated.

Entire CLI Integration

Entire CLI: https://github.com/entireio/cli

When tool access is available, detect Entire at activation:

entire status 2>/dev/null

If it succeeds, mention that intent records will be captured in the session transcript on the checkpoint branch. This enables learning-aggregator --deep to later mine intent frames and drift events for cross-session scope-drift patterns.
If unavailable/failing, continue silently. Do not block execution and do not nag about installation.

Copilot/chat fallback:

If command execution is unavailable, skip detection and continue with the same intent workflow in chat output.

How intent frames become learning signals

Each Intent Frame and Intent Check you emit is captured verbatim in Entire's session transcript. At cadence, learning-aggregator --deep reads those transcripts and extracts:

Frames that were resolved as Abandoned or Pivoted → potential planning gaps
Drift signals that repeatedly fire in similar contexts → potential scope definition issues
Constraint violations detected by drift checks → patterns for promotion to project instruction files

You do not need to do anything special for this — the intent blocks are structured (## Intent Frame #N, ## Intent Check, ## Intent Resolution), which makes them parseable from the transcript.

Guardrails

Keep it lightweight; avoid long prose.
Do not over-trigger on trivial tasks.
Do not interrupt on every small step.
Treat acknowledged pivots as valid.
Preserve exact structured block headers/fields for parseability.

Interoperability with Other Skills

Use this skill as the front-door alignment layer for non-trivial coding work:

plan-interview (optional, for requirement shaping)
intent-framed-agent (execution contract + scope drift monitoring)
context-surfing (context quality monitoring — runs concurrently with intent-framed-agent during execution)
simplify-and-harden (post-completion quality/security pass)
self-improvement (capture recurring patterns and promote durable rules)

Relationship with context-surfing

Both skills are live during execution. They monitor different failure modes:

intent-framed-agent monitors scope drift — is the agent doing the right thing? It fires structured Intent Checks when work moves outside the stated outcome.
context-surfing monitors context quality drift — is the agent still capable of doing it well? It fires when the agent's own coherence degrades (hallucination, contradiction, hedging).

They are complementary, not redundant. An agent can be perfectly on-scope while its context quality degrades. Conversely, scope drift can happen with perfect context quality. Intent Checks continue firing alongside context-surfing's wave monitoring.

Precedence rule: If both skills fire simultaneously (an Intent Check and a context-surfing drift exit at the same time), the drift exit takes precedence. Degraded context makes scope checks unreliable — resolve the context issue first, then resume scope monitoring in the next session.

Cadence separation: Intent Checks fire at scope boundaries — before touching a new area/file, before starting a new logical work unit, when the current action feels tangential. Context-surfing's pre-commit anchor check fires at side-effecting-action moments — specific tool calls, writes, commits, commit-level output. Don't run both in the same beat: if an Intent Check has just fired and resolved cleanly, the next side-effecting action inside the same work unit doesn't need a fresh anchor check — you already re-grounded.

What this skill produces

Intent frame artifact — consumed by context-surfing as part of the wave anchor and copied verbatim into handoff files on drift exit.
Intent resolution — signals task completion, which triggers simplify-and-harden.
Drift observations — scope drift patterns can be logged to self-improvement as learnings if they recur.

intent-framed-agent

Intent Framed Agent

Install

Purpose