/context-surfing

name: context-surfing
description: >
  Monitors context window health throughout a session and rides peak context quality for maximum output fidelity.
  Activates automatically after plan-interview and intent-framed-agent. Stays active through execution and hands off
  cleanly to simplify-and-harden and self-improvement when the wave completes naturally or exits via handoff.
  Use this skill whenever a multi-step agent task is underway and session continuity or context drift is a concern.
  Especially important for long-running tasks, complex refactors, or any work where degraded context would silently
  corrupt the output. Trigger even if the user doesn't say "context surfing" — if an agent task is running across
  multiple steps with intent and a plan already established, this skill is live.

Context Surfing

Install

gh skill install pskoett/pskoett-skills context-surfing

Fallback using the Agent Skills CLI:

npx skills add pskoett/pskoett-skills/skills/context-surfing

The agent rides the wave of peak context. When the wave crests, it commits. When it detects drift, it pulls out cleanly — saving state, handing off, and letting the next session catch the next wave.

No wipeouts. No zombie sessions. Only intentional, high-fidelity execution.

---

Mental Model

Think of context like an ocean wave:

• **Paddling in** = loading the intent frame, plan, and initial context. Energy is building.
• **The peak** = full context coherence. The agent knows exactly what it's doing and why. This is when to execute.
• **The shoulder** = context starting to flatten. Still rideable, but output density is dropping.
• **The close-out** = drift. Contradiction, hedging, second-guessing, or hallucinated details. Wipe-out territory.

The skill's job: ride as long as the wave is good, exit before it closes out.

---

Lifecycle Position

[plan-interview] → [intent-framed-agent] → [context-surfing ACTIVE] → [verify-gate] → [simplify-and-harden] → [self-improvement]

Context Surfing is the execution layer. It wraps all work between intent capture and post-completion review. Simplify-and-harden and self-improvement are the next steps in the pipeline — they run after context-surfing completes, not as conditions that end it.

Relationship with intent-framed-agent

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

• **intent-framed-agent** monitors *scope* drift — am I doing the right thing? It fires structured Intent Checks when work moves outside the stated outcome.
• **context-surfing** monitors *context quality* drift — am I 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 (e.g., it's doing the right thing but starting to hallucinate details). Conversely, scope drift can happen with perfect context quality (the agent deliberately chases a tangent). Intent-framed-agent's Intent Checks continue firing alongside context-surfing's wave monitoring.

**Precedence rule:** If both skills fire simultaneously (an Intent Check and a drift exit at the same time), context-surfing's 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 current action feels tangential"* (`intent-framed-agent/SKILL.md`). 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 that same work unit doesn't need a fresh anchor check — you already re-grounded.

When to Use the Full Pipeline

Not every task needs every skill in the pipeline. Match pipeline depth to task complexity:

| Task Type | Skills to Use | |-----------|---------------| | Trivial (rename, typo fix) | None — just do it | | Small (isolated bug fix, single-file change) | `verify-gate` + `simplify-and-harden` | | Medium (feature in known area, multi-file) | `intent-framed-agent` + `verify-gate` + `simplify-and-harden` | | Large (complex refactor, new architecture, unfamiliar codebase) | Full pipeline | | Long-running (multi-session, high context pressure) | Full pipeline with `context-surfing` as the critical skill |

This table matches `skill-pipeline`'s task classification, which is the canonical routing source.

When in doubt, start light. Add skills if you notice drift or quality issues mid-task.

---

Activation

This skill is live the moment the intent frame and plan are established. No explicit invocation needed.

At activation, load whatever anchors are available:

1. The intent frame (from intent-framed-agent output) — if available 2. The plan (from plan-interview output) — if available 3. The current session state from the Entire CLI (if available) 4. All project context files (see below)

If neither an intent frame nor a plan exists (standalone mode), use the user's original task description combined with project context files as the wave anchor. This is sufficient — the skill degrades gracefully, not catastrophically.

Entire CLI Integration

Entire CLI ([github.com/entireio/cli](https://github.com/entireio/cli)) provides persistent session state that serves as external ground truth for drift checks and handoff files.

At activation, detect Entire:

entire status 2>/dev/null

• If it succeeds, Entire captures the session passively via hooks — every prompt, tool call, file modification, and checkpoint is recorded to the shadow branch. You don't need to call Entire directly; the harness handles it. Use `entire status` and `entire expla