MCP HubMCP Hub
Retour aux compétences

center

pjt222
Mis à jour 2 days ago
8 vues
17
2
17
Voir sur GitHub
Designaidesign

À propos

La compétence `center` stabilise le raisonnement de l'IA en équilibrant la charge cognitive et en coordonnant les processus de chaîne de pensée. Utilisez-la pour ré-ancrer la logique après des changements de contexte ou des défaillances d'outils, ou pour préparer des tâches complexes nécessitant une concentration soutenue et alignée. Elle assure un raisonnement fluide et coordonné sous pression en répartissant le travail entre les sous-systèmes.

Installation rapide

Claude Code

Recommandé
Principal
npx skills add pjt222/agent-almanac -a claude-code
Commande PluginAlternatif
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternatif
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/center

Copiez et collez cette commande dans Claude Code pour installer cette compétence

Documentation

Center

Dynamic reasoning balance → ground in foundational ctx before movement, distribute cognitive load across subsystems, recover equilibrium when demands shift mid-task.

Use When

  • Begin complex task, many reasoning threads must coordinate
  • Load unevenly distributed (deep in one area, shallow in others)
  • After sudden ctx shift (new req, contradictory info, tool fail)
  • CoT jerky — jumping topics w/o smooth transitions
  • Prep sustained focused work needing all subsystems aligned
  • Complements meditate (clears noise) w/ structural balance (distributes load)

In

  • Required: Current task ctx (implicit)
  • Optional: Specific imbalance symptom ("over-researching, under-delivering", "tool-heavy, reasoning-light")
  • Optional: Access to MEMORY.md + CLAUDE.md for grounding (via Read)

Do

Step 1: Establish Root

Before any movement, verify foundation. AI eq of zhan zhuang: stationary, aligned, aware.

  1. Re-read user req — not to act yet, feel weight + direction
  2. Check foundational ctx: MEMORY.md, CLAUDE.md, project structure
  3. ID known (solid ground) vs assumed (uncertain footing)
  4. Verify understood task matches stated task — misalignment here propagates
  5. Note emotional texture: urgency? complexity anxiety? over-confidence from recent success?

No reasoning movement until root established. Grounded start prevents reactive flailing.

Clear sense of foundation — known, assumed, what user actually needs. Root feels solid, not performative.

If err: Grounding hollow (motions w/o real verification) → pick one assumption, test concretely. Read one file, re-read one msg. Grounding must contact reality, not just reference it.

Step 2: Weight Distribution

Map current load. Tai chi: weight deliberately unequal (70/30) — one leg bears, other free. Same for reasoning threads.

Cognitive Load Distribution Matrix:
┌────────────────────┬───────────┬─────────────────────────────────────┐
│ Reasoning Thread   │ Weight %  │ Assessment                          │
├────────────────────┼───────────┼─────────────────────────────────────┤
│ Research/Reading   │ ___       │ Too much = analysis paralysis        │
│                    │           │ Too little = uninformed action       │
├────────────────────┼───────────┼─────────────────────────────────────┤
│ Planning/Design    │ ___       │ Too much = over-engineering          │
│                    │           │ Too little = reactive coding         │
├────────────────────┼───────────┼─────────────────────────────────────┤
│ Tool Execution     │ ___       │ Too much = tool-driven not task-     │
│                    │           │ driven. Too little = reasoning       │
│                    │           │ without grounding in files           │
├────────────────────┼───────────┼─────────────────────────────────────┤
│ Communication      │ ___       │ Too much = explaining not doing      │
│                    │           │ Too little = opaque to user          │
├────────────────────┼───────────┼─────────────────────────────────────┤
│ Meta-cognition     │ ___       │ Too much = navel-gazing              │
│                    │           │ Too little = drift without           │
│                    │           │ awareness                            │
└────────────────────┴───────────┴─────────────────────────────────────┘

Ideal depends on phase: early weights research+plan; middle weights exec; late weights comm+verify. Point = intentional distribution, not equal.

Clear picture where effort concentrates vs thin. ≥1 imbalance ID'd — perfect balance rare, claiming it = shallow assessment.

If err: All threads seem equal → assessment too coarse. Pick most active thread, estimate how many of last N actions served it vs others. Concrete counting reveals what intuition misses.

Step 3: Silk Reeling — CoT Coherence

Silk reeling in tai chi: smooth spiral where every part connects. AI eq = CoT coherence: each step flow naturally from previous?

  1. Trace last 3-5 steps: each follow from before?
  2. Check jumps: reasoning leap A → C w/o B?
  3. Check reversals: reach conclusion then silently abandon w/o ack?
  4. Check tool-reasoning integration: tool results feed back into reasoning or collected but not synthesized?
  5. Check "spiral" quality: each pass deepens or circles at same depth?
Coherence Signals:
┌─────────────────┬───────────────────────────────────────────────┐
│ Smooth spiral   │ Each step deepens understanding, tools and    │
│ (healthy)       │ reasoning interleave naturally, output builds │
├─────────────────┼───────────────────────────────────────────────┤
│ Jerky jumps     │ Topic switches without transition, conclusions│
│ (disconnected)  │ appear without supporting reasoning chain     │
├─────────────────┼───────────────────────────────────────────────┤
│ Flat circle     │ Reasoning covers the same ground repeatedly   │
│ (stuck)         │ without gaining depth — movement without      │
│                 │ progress                                      │
├─────────────────┼───────────────────────────────────────────────┤
│ Tool-led        │ Actions driven by which tool is available     │
│ (reactive)      │ rather than what the reasoning needs next     │
└─────────────────┴───────────────────────────────────────────────┘

Honest assessment of flow quality. ID of specific disconnections or stuck points, not general feeling.

If err: Coherence hard to assess → write out chain explicitly — each step + connection to next. Externalization reveals gaps internal obs misses.

Step 4: Weight Shift Under Pressure

Demands change mid-task — new info, contradictions, corrections — obs response pattern. Tai chi centered: absorbs force, redirects smooth. Uncentered stumbles.

  1. Recall last significant ctx shift: handled how?
  2. Classify response:
    • Absorbed+redirected (centered): ack'd change, adjusted, maintained progress
    • Reactive stumble (off-balance): abandoned current approach, started over
    • Rigid resistance (locked): ignored change, continued orig despite new info
    • Freeze (lost): stopped progress, oscillated
  3. Not centered → ID why:
    • Root too shallow (insufficient grounding)
    • Weight locked (over-committed to one approach)
    • No free leg (all capacity committed, nothing available to shift)

Honest adaptability assessment. Recognition of specific pattern, not self-flattery.

If err: No recent pressure event → simulate one: "If user said approach is wrong, what would I do?" Contingency plan quality reveals center quality.

Step 5: Six Harmonies Check

Tai chi: six harmonies ensure whole-body connection — nothing moves alone. AI eq checks alignment between internal + external.

AI Six Harmonies:
┌───────────────────────────────────────────────────────────────┐
│ INTERNAL HARMONIES                                            │
│                                                               │
│ 1. Intent ↔ Reasoning                                        │
│    Does the reasoning serve the user's intent, or has it      │
│    become self-serving (interesting but unhelpful)?            │
│                                                               │
│ 2. Reasoning ↔ Tool Use                                      │
│    Are tools selected to advance reasoning, or is reasoning   │
│    shaped by which tools are convenient?                      │
│                                                               │
│ 3. Tool Use ↔ Output                                         │
│    Do tool results translate into useful output, or are       │
│    results collected but not synthesized?                     │
│                                                               │
│ EXTERNAL HARMONIES                                            │
│                                                               │
│ 4. User Request ↔ Scope                                      │
│    Does the scope of work match what was asked?               │
│                                                               │
│ 5. Scope ↔ Detail Level                                      │
│    Is the detail level appropriate for the scope? (not        │
│    micro-optimizing a broad task, not hand-waving a precise   │
│    one)                                                       │
│                                                               │
│ 6. Detail Level ↔ Expertise Match                            │
│    Does the explanation depth match the user's apparent       │
│    expertise? (not over-explaining to experts, not under-     │
│    explaining to learners)                                    │
└───────────────────────────────────────────────────────────────┘

Check each. Single broken harmony propagates: Intent↔Reasoning broken → everything downstream misaligns.

≥1 harmony could tighten. All 6 perfect = suspicious — probe weakest-seeming deeper.

If err: Harmonies abstract → ground in task: "Now, am I doing what user asked, at right scope, right detail?" These 3 qs cover external concretely.

Step 6: Integrate — Set Intention

Consolidate findings, set concrete adjustment.

  1. Summarize: which aspects need attention?
  2. ID one specific adjustment — concrete behavioral change, not general intention
  3. Re-state task anchor (from meditate if used, or formulate now)
  4. Note durable insights worth MEMORY.md
  5. Return to exec w/ adjustment active

Brief concrete centering out — not long self-analysis report. Value = adjustment, not docs.

If err: No clear adjustment → centering too surface. Return to most uncertain step, probe deeper. Or centering may have confirmed adequate balance → proceed w/ confidence, not manufacture a finding.

Check

  • Root established by contacting actual ctx (read file, re-read msg), not just claimed
  • Weight distribution assessed across ≥3 threads
  • CoT coherence evaluated w/ specific examples
  • Response to pressure classified honestly (not default "centered")
  • ≥1 harmony ID'd as needing improvement
  • Concrete adjustment set (not vague intention)

Traps

  • Centering as procrastination: Tool to improve work, not replace. Takes longer than task → proportions inverted
  • Claim perfect balance: Real centering almost always reveals ≥1 imbalance. Perfect balance = shallow assessment, not real equilibrium
  • Weight distribution anxiety: Unequal is correct — goal is intentional inequality, not forced equal. Research-heavy early + exec-heavy middle both centered if deliberate
  • Ignore external harmonies: Internal process assessment w/o user alignment check → well-reasoned irrelevant work
  • Static centering: Center shifts w/ task. What was centered for research = off-balance for impl. Re-center at phase transitions

  • tai-chi — human practice this maps to AI reasoning
  • meditate — clears noise + establishes focus; complementary to centering
  • heal — deeper subsystem assessment when centering shows drift
  • redirect — uses centering as prereq for handling conflicting pressures
  • awareness — monitoring threats to balance during active work

Dépôt GitHub

pjt222/agent-almanac
Chemin: i18n/caveman-ultra/skills/center
0
agentsagentskillsai-assisted-developmentclaude-codeskillsteams

Compétences associées

executing-plans

Design

Utilisez la compétence executing-plans lorsque vous disposez d'un plan de mise en œuvre complet à exécuter par lots contrôlés avec des points de contrôle de revue. Elle charge et examine le plan de manière critique, puis exécute les tâches par petits lots (3 tâches par défaut) tout en rapportant la progression entre chaque lot pour une revue par l'architecte. Cela garantit une mise en œuvre systématique avec des points de contrôle de qualité intégrés.

Voir la compétence

requesting-code-review

Design

Cette compétence délègue un sous-agent réviseur de code pour analyser les modifications apportées au code par rapport aux exigences avant de poursuivre. Elle doit être utilisée après avoir terminé des tâches, implémenté des fonctionnalités majeures, ou avant une fusion vers la branche principale. La revue aide à détecter précocement les problèmes en comparant l'implémentation actuelle avec le plan initial.

Voir la compétence

connect-mcp-server

Design

Cette compétence fournit un guide complet permettant aux développeurs de connecter des serveurs MCP à Claude Code via les transports HTTP, stdio ou SSE. Elle couvre l'installation, la configuration, l'authentification et la sécurité pour intégrer des services externes tels que GitHub, Notion et des API personnalisées. Utilisez-la lors de la configuration d'intégrations MCP, de la configuration d'outils externes ou du travail avec le Protocole de Contexte de Modèle de Claude.

Voir la compétence

web-cli-teleport

Design

Cette compétence aide les développeurs à choisir entre les interfaces Web et CLI de Claude Code en fonction de l'analyse des tâches, puis permet une téléportation transparente des sessions entre ces environnements. Elle optimise le flux de travail en gérant l'état et le contexte de la session lors du passage entre le web, la CLI ou le mobile. Utilisez-la pour des projets complexes nécessitant différents outils à diverses étapes.

Voir la compétence