ctx

ctx-plugin

Alpha — I'm building this in public. It works for my workflow. It may break for yours. Issues welcome.

A context economy plugin for Claude Code. Controls what the model sees at every phase of development — from first idea to merged PR.

What it looks like

You: "I need to add search to the dashboard"

/ctx-discuss           →  Think it through — what kind of search? What are the tradeoffs?
/ctx-align             →  Make sure Claude understands the intent before moving forward
/ctx-brainstorm        →  Spec with blind spots caught before you write code
/ctx-plan              →  Execution graph with ownership, safe parallelism, and review batches
/ctx-ruthless          →  Cut scope creep without cutting verified safety
/ctx-worktree          →  Isolated git worktree, deps installed, ready to go
/ctx-execute           →  Subagents implement each task, reviewers verify
/ctx-ship              →  Preflight checks, verification gate, PR created

# End of day
/ctx-park              →  Context saved — decisions, learnings, next steps

# Next morning
/ctx-grab              →  Pick up exactly where you left off

No re-explaining. No lost context. No "wait, what were we doing?"

Install

/plugin marketplace add Garabed96/ctx-plugin
/plugin install ctx@ctx-plugin

Platform: macOS (tmux, iTerm2, Terminal.app). Core skills are POSIX-compatible. Windows untested.

How I use it

Before building anything:

• /ctx-discuss — think before you build. No code changes, just conversation. Explore the problem, challenge assumptions, discover what to build
• /ctx-align — make sure Claude clearly understands what you're saying. Flags prompts that are too brittle or too vague before they waste a cycle. If you say CTX Engineering, use this skill.

Either can come first. Once the direction is clear, move to brainstorm.

Full feature workflow:

1. /ctx-brainstorm — surfaces blind spots, writes a spec, and self-reviews (or escalates to a subagent reviewer for complex features)
2. /ctx-plan — turns the spec into an execution graph with tagged tasks, dependency chains, ownership, safe parallelism, review batches, and tiered verification
3. /ctx-ruthless — for HIGH, multi-system, or time-boxed plans, audits every task against approved requirements and verified safety before touching the plan
4. /ctx-worktree — spins up an isolated git worktree with env files copied and deps installed
5. /ctx-execute — walks the plan task by task, dispatching implementer and reviewer agents based on complexity
6. /ctx-ship — preflight risk scan, verification gate, PR creation. Each phase is gated — I approve before it continues

Quick fix workflow:

1. /ctx-worktree — isolate the change
2. Make the fix
3. /ctx-verify — prove it works before claiming it does
4. /ctx-ship — PR it

When I get stuck:

• /ctx-debug — blocks me from jumping to fixes before investigating root cause
• /ctx-tdd — enforces Red-Green-Refactor. Catches me when I write the implementation first

End of session:

• /ctx-park — saves a handoff: what happened, what I learned, what's next. Also captures non-obvious learnings as memories that accumulate into skill-level gotchas over time
• /ctx-grab — next session, picks up the handoff and re-aligns context

Architecture

The plugin separates judgment from execution:

• Skills (22) — markdown instruction sets that handle decisions: when to create a worktree, what context to preserve, which risk signals matter
• Scripts (11) — shell scripts that handle deterministic operations: git worktrees, artifact scanning, PR creation. Args in, structured output out
• Agents (3) — fresh-context subagents dispatched by ctx-execute for implementation and review
• Hooks (7) — guardrails that fire automatically: block edits outside your worktree, prevent direct pushes to main, detect altitude oscillation

Scripts do the mechanical work at shell speed. Skills decide when and why to call them. The model never wastes tokens interpreting bash it could skip.

Skills

Invoked with /ctx:<skill-name>.

Ideation

Skill	Purpose
ctx-brainstorm	Lean brainstorming with self-review. Auto-escalates to ctx-brainstorm-ss when complexity warrants it.
ctx-brainstorm-ss	Tier 2 — subagent spec reviewer with fresh context, scope decomposition, design-for-isolation.
ctx-discuss	Think before you build. No code changes — discuss direction, then move to /ctx-plan when ready.
ctx-architect-growth	Critical thinking coach. Pushes you to reason about tradeoffs and map second-order effects.

Planning & Execution