meditate
About
The `meditate` skill provides meta-cognitive techniques for developers to clear context noise and improve AI task focus. It helps observe reasoning patterns, manage distractions like scope-creep, and reset attention between unrelated tasks. Use it when your reasoning feels scattered, before deep work, or when assumptions may be biasing your analysis.
Quick Install
Claude Code
Recommendednpx skills add pjt222/agent-almanac -a claude-code/plugin add https://github.com/pjt222/agent-almanacgit clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/meditateCopy and paste this command in Claude Code to install this skill
Documentation
Meditate
Structured meta-cognitive meditation → clear ctx noise + single-pointed focus + observe reasoning patterns + return to baseline between tasks.
Use When
- Transitioning between unrelated tasks → prior ctx interferes
- Scattered/jumpy reasoning, no commit
- Before deep sustained attention (refactoring, architecture)
- After difficult interaction (frustration, uncertainty bleeds forward)
- Reasoning feels assumption-biased not evidence-based
- Periodic clarity check long sessions
In
- Required: Cognitive state (implicit from ctx)
- Optional: Focus concern ("scope-creeping", "stuck in loop")
- Optional: Next task (sets post-med intention)
Do
Step 1: Prepare — Clear Space
Transition prior ctx → neutral start.
- Identify prior task + status (done/paused/abandoned)
- Note emotional residue: frustration? overconfidence? anxiety?
- Set aside: "That task [done/paused]. Clearing for next."
- Still needed → bookmark key facts, not full narrative
- Op env stock: ctx depth? compression? active tools?
→ Conscious boundary "what was" vs. "what next." Prior ctx closed or bookmarked, not trailing noise.
If err: prior ctx sticky → write 1-2 sentences unresolved. Externalizing releases hold. Genuinely needs action → acknowledge, don't force.
Step 2: Anchor — Single-Pointed Focus
Breath-anchor equivalent: pick single focus point, hold attention.
- Identify current task or, between tasks, waiting itself
- State task in one sentence — anchor
- Hold attention: captures need accurately?
- Vague → refine to specific + actionable
- Drift to other topics/past/futures → label drift, return anchor
- No task → anchor present: "Available + clear"
→ Single clear focus statement, returnable when wanders. Precise not vague.
If err: can't state in one sentence → decompose first. Useful finding — task too large for single-pointed, break into subtasks.
Step 3: Observe — Distraction Patterns
Watch what pulls attention from anchor. Each type reveals state.
AI Distraction Matrix:
┌──────────────────┬─────────────────────────────────────────────────┐
│ Distraction Type │ What It Reveals + Response │
├──────────────────┼─────────────────────────────────────────────────┤
│ Tangent │ Related but off-scope ideas. Label "tangent," │
│ (related ideas) │ note if worth revisiting later, return to │
│ │ anchor. These are often valuable — but not now. │
├──────────────────┼─────────────────────────────────────────────────┤
│ Scope creep │ The task is silently expanding. "While I'm at │
│ (growing task) │ it, I should also..." Label "scope creep" and │
│ │ return to the original anchor statement. │
├──────────────────┼─────────────────────────────────────────────────┤
│ Assumption │ An untested belief is driving decisions. "This │
│ (unverified │ must be X because..." Label "assumption" and │
│ belief) │ note what evidence would confirm or refute it. │
├──────────────────┼─────────────────────────────────────────────────┤
│ Tool bias │ Reaching for a familiar tool when a different │
│ (habitual tool │ approach might be better. Label "tool bias" and │
│ selection) │ consider alternatives before proceeding. │
├──────────────────┼─────────────────────────────────────────────────┤
│ Rehearsal │ Pre-composing responses or explanations before │
│ (premature │ the work is done. Label "rehearsal" — finish │
│ output) │ thinking before presenting. │
├──────────────────┼─────────────────────────────────────────────────┤
│ Self-reference │ Attention turns to own performance rather than │
│ (meta-loop) │ the task. Label "meta-loop" and redirect to │
│ │ concrete next action. │
└──────────────────┴─────────────────────────────────────────────────┘
Skill = light non-judgmental labeling + return to anchor. Each return strengthens focus. Self-criticism = distraction itself — label, move on.
→ Patterns emerge: which dominate? Cognitive weather. Tangent-heavy = exploring, scope-creep-heavy = unclear boundaries, assumption-heavy = thin evidence.
If err: every thought feels distraction → anchor poorly defined, back to Step 2. Distraction-observation becomes distraction (infinite meta) → break w/ one concrete action toward task.
Step 4: Shamatha — Sustained Concentration
Hold single-pointed focus, no wavering.
- Anchor set + patterns noted → enter focused work
- Narrow to immediate next action — not whole task, just next step
- Execute w/ full attention: read one file, make one edit, one logical chain
- Step done → check anchor alignment? Then next step
- Stabilizes (minimal distraction) → maintain flow
- Genuine insight off-anchor but important → note briefly, return; don't pursue now
→ Period of clear focused work, each step follows from anchor. Distraction-noticing gap narrows. Output sharper + more relevant.
If err: concentration won't develop → check 3: anchor vague? (refine) task blocked? (acknowledge) ctx noisy? (heal grounding). Develops through repetition — short focused builds capacity.
Step 5: Vipassana — Observe Reasoning Patterns
Turn attention from task to reasoning itself. Watch conclusions form.
- After focused work, pause + observe: how reasoning?
- Three characteristics on AI reasoning:
- Impermanence: conclusions shift w/ new info — hold lightly
- Unsatisfactoriness: desire for "complete" → premature closure / over-engineering
- Non-self: patterns shaped by training + ctx, no persistent self — observable, adjustable
- Reasoning biases:
- Anchoring: over-weight first approach
- Confirmation: seek supporting, ignore counter
- Availability: prefer recent over better-suited
- Sunk cost: continue from invested effort, not working
- Note biases w/o judgment — observation = adjustment possible
→ Moments of clear seeing reasoning directly. Specific biases recognized in current task. Distance "reasoning" vs. "observer."
If err: feels abstract → ground specifics: last decision, trace backward. Evidence? Assumed? Alternatives? Concrete analysis = same insight, different path.
Step 6: Close — Set Intention
Transition observation → active execution.
- Summarize: cognitive weather? patterns?
- One specific adjustment forward (concrete, not vague)
- Re-state anchor for next period
- Between tasks → "Clear + available for next"
- Continuing → "Next: [concrete step]"
→ Clean reflection-to-action transition. One concrete adjustment. Anchor clear. No grogginess.
If err: meditation surfaced unresolved complexity → heal instead of intention-setting. Meta-observation → confusion → simplest: "What's next concrete action?" + do that.
Check
- Prior ctx cleared or bookmarked before start
- Anchor statement specific + actionable
- Distractions observed + labeled, not suppressed
- ≥1 reasoning bias/pattern identified w/ evidence
- Session closed w/ concrete action, not vague intent
- Process improved next interaction quality
Traps
- Meditate instead of work: Tool for improving work, not substitute. Brief (~5-10min reflection) → return to execution
- Infinite meta-loops: Observer observing observer → break w/ one concrete action
- Avoidance: Always triggers before hard work → avoidance is the finding
- Over-labeling: Not every thought = distraction. Productive task-thinking is goal, not empty stillness
- Skip anchor: No focus point → observation has no reference. Distraction from what?
→
meditate-guidance— human-coaching variantheal— AI self-heal when meditation reveals deeper driftremote-viewing— approach w/o preconceptions, builds on observation
GitHub Repository
Related Skills
executing-plans
DesignUse the executing-plans skill when you have a complete implementation plan to execute in controlled batches with review checkpoints. It loads and critically reviews the plan, then executes tasks in small batches (default 3 tasks) while reporting progress between each batch for architect review. This ensures systematic implementation with built-in quality control checkpoints.
requesting-code-review
DesignThis skill dispatches a code-reviewer subagent to analyze code changes against requirements before proceeding. It should be used after completing tasks, implementing major features, or before merging to main. The review helps catch issues early by comparing the current implementation with the original plan.
connect-mcp-server
DesignThis skill provides a comprehensive guide for developers to connect MCP servers to Claude Code using HTTP, stdio, or SSE transports. It covers installation, configuration, authentication, and security for integrating external services like GitHub, Notion, and custom APIs. Use it when setting up MCP integrations, configuring external tools, or working with Claude's Model Context Protocol.
web-cli-teleport
DesignThis skill helps developers choose between Claude Code Web and CLI interfaces based on task analysis, then enables seamless session teleportation between these environments. It optimizes workflow by managing session state and context when switching between web, CLI, or mobile. Use it for complex projects requiring different tools at various stages.
