Initial commit

skills/layered-reasoning/SKILL.md

@@ -0,0 +1,297 @@
+---
+name: layered-reasoning
+description: Use when reasoning across multiple abstraction levels (strategic/tactical/operational), designing systems with hierarchical layers, explaining concepts at different depths, maintaining consistency between high-level principles and concrete implementation, or when users mention 30,000-foot view, layered thinking, abstraction levels, top-down design, or need to move fluidly between strategy and execution.
+---
+
+# Layered Reasoning
+
+## Purpose
+
+Layered reasoning structures thinking across multiple levels of abstraction—from high-level principles (30,000 ft) to tactical approaches (3,000 ft) to concrete actions (300 ft). Good layered reasoning maintains consistency: lower layers implement upper layers, upper layers constrain lower layers, and each layer is independently useful.
+
+Use this skill when:
+- **Designing systems** with architectural layers (strategy → design → implementation)
+- **Explaining complex topics** at multiple depths (executive summary → technical detail → code)
+- **Strategic planning** connecting vision → objectives → tactics → tasks
+- **Ensuring consistency** between principles and execution
+- **Bridging communication** between stakeholders at different levels (CEO → manager → engineer)
+- **Problem-solving** where high-level constraints must guide low-level decisions
+
+Layered reasoning prevents inconsistency: strategic plans that can't be executed, implementations that violate principles, or explanations that confuse by jumping abstraction levels.
+
+---
+
+## Common Patterns
+
+### Pattern 1: 30K → 3K → 300 ft Decomposition (Top-Down)
+
+**When**: Starting from vision/principles, deriving concrete actions
+
+**Structure**:
+- **30,000 ft (Strategic)**: Why? Core principles, invariants, constraints (e.g., "Customer privacy is non-negotiable")
+- **3,000 ft (Tactical)**: What? Approaches, architectures, policies (e.g., "Zero-trust security model, end-to-end encryption")
+- **300 ft (Operational)**: How? Specific actions, procedures, code (e.g., "Implement AES-256 encryption for data at rest")
+
+**Example**: Product strategy
+- **30K**: "Become the most trusted platform" (principle)
+- **3K**: "Achieve SOC 2 compliance, publish security reports, 24/7 support" (tactics)
+- **300 ft**: "Implement MFA, conduct quarterly audits, hire 5 support engineers" (actions)
+
+**Process**: (1) Define strategic layer invariants, (2) Derive tactical options that satisfy invariants, (3) Select tactics, (4) Design operational procedures implementing tactics, (5) Validate operational layer doesn't violate strategic constraints
+
+### Pattern 2: Bottom-Up Aggregation
+
+**When**: Starting from observations/data, building up to principles
+
+**Structure**:
+- **300 ft**: Specific observations, measurements, incidents (e.g., "User A clicked 5 times, User B abandoned")
+- **3,000 ft**: Patterns, trends, categories (e.g., "40% abandon at checkout, slow load times correlate with abandonment")
+- **30,000 ft**: Principles, theories, root causes (e.g., "Performance impacts conversion; every 100ms costs 1% conversion")
+
+**Example**: Engineering postmortem
+- **300 ft**: "Service crashed at 3:42 PM, memory usage spiked to 32GB, 500 errors returned"
+- **3K**: "Memory leak in caching layer, triggered by specific API call pattern under load"
+- **30K**: "Our caching strategy lacks eviction policy; need TTL-based expiration for all caches"
+
+**Process**: (1) Collect operational data, (2) Identify patterns and group, (3) Formulate hypotheses at tactical layer, (4) Validate with more data, (5) Distill strategic principles
+
+### Pattern 3: Layer Translation (Cross-Layer Communication)
+
+**When**: Explaining same concept to different audiences (CEO, manager, engineer)
+
+**Technique**: Translate preserving core meaning while adjusting abstraction
+
+**Example**: Explaining tech debt
+- **CEO (30K)**: "We built quickly early on. Now growth slows 20% annually unless we invest $2M to modernize."
+- **Manager (3K)**: "Monolithic architecture prevents independent team velocity. Migrate to microservices over 6 months."
+- **Engineer (300 ft)**: "Extract user service from monolith. Create API layer, implement service mesh, migrate traffic."
+
+**Process**: (1) Identify audience's layer, (2) Extract core message, (3) Translate using concepts/metrics relevant to that layer, (4) Maintain causal links across layers
+
+### Pattern 4: Constraint Propagation (Top-Down)
+
+**When**: High-level constraints must guide low-level decisions
+
+**Mechanism**: Strategic constraints flow down, narrowing options at each layer
+
+**Example**: Healthcare app design
+- **30K constraint**: "HIPAA compliance is non-negotiable" (strategic)
+- **3K derivation**: "All PHI must be encrypted, audit logs required, access control mandatory" (tactical)
+- **300 ft implementation**: "Use AWS KMS for encryption, CloudTrail for audits, IAM for access" (operational)
+
+**Guardrail**: Lower layers cannot violate upper constraints (e.g., operational decision to skip encryption violates strategic constraint)
+
+### Pattern 5: Emergent Property Recognition (Bottom-Up)
+
+**When**: Lower-layer interactions create unexpected upper-layer behavior
+
+**Example**: Team structure
+- **300 ft**: "Each team owns microservice, deploys independently, uses Slack for coordination"
+- **3K emergence**: "Conway's Law: architecture mirrors communication structure; slow cross-team features"
+- **30K insight**: "Org structure determines system architecture; realign teams to product lines, not services"
+
+**Process**: (1) Observe operational behavior, (2) Identify emerging patterns at tactical layer, (3) Recognize strategic implications, (4) Adjust strategy if needed
+
+### Pattern 6: Consistency Checking Across Layers
+
+**When**: Validating that all layers align (no contradictions)
+
+**Check types**:
+- **Upward consistency**: Do operations implement tactics? Do tactics achieve strategy?
+- **Downward consistency**: Can strategy be executed with these tactics? Can tactics be implemented operationally?
+- **Lateral consistency**: Do parallel tactical choices contradict? Do operational procedures conflict?
+
+**Example inconsistency**: Strategy says "Move fast," tactics say "Extensive approval process," operations say "3-week release cycle" → Contradiction
+
+**Fix**: Align layers. Either (1) change strategy ("Move carefully"), (2) change tactics ("Lightweight approvals"), or (3) change operations ("Daily releases")
+
+---
+
+## Workflow
+
+Use this structured approach when applying layered reasoning:
+
+```
+□ Step 1: Identify relevant layers and abstraction levels
+□ Step 2: Define strategic layer (principles, invariants, constraints)
+□ Step 3: Derive tactical layer (approaches that satisfy strategy)
+□ Step 4: Design operational layer (concrete actions implementing tactics)
+□ Step 5: Validate consistency across all layers
+□ Step 6: Translate between layers for different audiences
+□ Step 7: Iterate based on feedback from any layer
+□ Step 8: Document reasoning at each layer
+```
+
+**Step 1: Identify relevant layers and abstraction levels** ([details](#1-identify-relevant-layers-and-abstraction-levels))
+Determine how many layers needed (typically 3-5). Map layers to domains: business (vision/strategy/execution), technical (architecture/design/code), organizational (mission/goals/tasks).
+
+**Step 2: Define strategic layer** ([details](#2-define-strategic-layer))
+Establish high-level principles, invariants, and constraints that must hold. These are non-negotiable and guide all lower layers.
+
+**Step 3: Derive tactical layer** ([details](#3-derive-tactical-layer))
+Generate approaches/policies/architectures that satisfy strategic constraints. Multiple tactical options may exist; choose based on tradeoffs.
+
+**Step 4: Design operational layer** ([details](#4-design-operational-layer))
+Create specific procedures, implementations, or actions that realize tactical choices. This is where execution happens.
+
+**Step 5: Validate consistency across all layers** ([details](#5-validate-consistency-across-all-layers))
+Check upward (do ops implement tactics?), downward (can strategy be executed?), and lateral (do parallel choices conflict?) consistency.
+
+**Step 6: Translate between layers for different audiences** ([details](#6-translate-between-layers-for-different-audiences))
+Communicate at appropriate abstraction level for each stakeholder. CEO needs strategic view, engineers need operational detail.
+
+**Step 7: Iterate based on feedback from any layer** ([details](#7-iterate-based-on-feedback-from-any-layer))
+If operational constraints make tactics infeasible, adjust tactics or strategy. If strategic shift occurs, propagate changes downward.
+
+**Step 8: Document reasoning at each layer** ([details](#8-document-reasoning-at-each-layer))
+Write explicit rationale at each layer explaining how it relates to layers above/below. Makes assumptions visible and aids future iteration.
+
+---
+
+## Critical Guardrails
+
+### 1. Maintain Consistency Across Layers
+
+**Danger**: Strategic goals contradict operational reality, or implementation violates principles
+
+**Guardrail**: Regularly check upward, downward, and lateral consistency. Propagate changes bidirectionally (strategy changes → update tactics/ops; operational constraints → update tactics/strategy).
+
+**Red flag**: "Our strategy is X but we actually do Y" signals layer mismatch
+
+### 2. Don't Skip Layers When Communicating
+
+**Danger**: Jumping from 30K to 300 ft confuses audiences, loses context
+
+**Guardrail**: Move through layers sequentially. If explaining to executive, start 30K → 3K (stop there unless asked). If explaining to engineer, provide 30K context first, then dive to 300 ft.
+
+**Test**: Can listener answer "why does this matter?" (links to upper layer) and "how do we do this?" (links to lower layer)
+
+### 3. Each Layer Should Be Independently Useful
+
+**Danger**: Layers that only make sense when combined, not standalone
+
+**Guardrail**: Strategic layer should guide decisions even without seeing operations. Tactical layer should be understandable without code. Operational layer should be executable without re-deriving strategy.
+
+**Principle**: Good layers can be consumed independently by different audiences
+
+### 4. Limit Layers to 3-5 Levels
+
+**Danger**: Too many layers create overhead; too few lose nuance
+
+**Guardrail**: For most domains, 3 layers sufficient (strategy/tactics/operations or architecture/design/code). Complex domains may need 4-5 but rarely more.
+
+**Rule of thumb**: Can you name each layer clearly? If not, you have too many.
+
+### 5. Upper Layers Constrain, Lower Layers Implement
+
+**Danger**: Treating layers as independent rather than hierarchical
+
+**Guardrail**: Strategic layer sets constraints ("must be HIPAA compliant"). Tactical layer chooses approaches within constraints ("encryption + audit logs"). Operational layer implements ("AES-256 + CloudTrail"). Cannot violate upward.
+
+**Anti-pattern**: Operational decision ("skip encryption for speed") violating strategic constraint ("HIPAA compliance")
+
+### 6. Propagate Changes Bidirectionally
+
+**Danger**: Strategic shift without updating tactics/ops, or operational constraint discovered but strategy unchanged
+
+**Guardrail**: **Top-down**: Strategy changes → re-evaluate tactics → adjust operations. **Bottom-up**: Operational constraint → re-evaluate tactics → potentially adjust strategy.
+
+**Example**: Strategy shift to "privacy-first" → Update tactics (end-to-end encryption) → Update ops (implement encryption). Or: Operational constraint (performance) → Tactical adjustment (different approach) → Strategic clarification ("privacy-first within performance constraints")
+
+### 7. Make Assumptions Explicit at Each Layer
+
+**Danger**: Implicit assumptions lead to inconsistency when assumptions violated
+
+**Guardrail**: Document assumptions at each layer. Strategic: "Assuming competitive market." Tactical: "Assuming cloud infrastructure." Operational: "Assuming Python 3.9+."
+
+**Benefit**: When assumptions change, know which layers need updating
+
+### 8. Recognize Emergent Properties
+
+**Danger**: Focusing only on designed properties, missing unintended consequences
+
+**Guardrail**: Regularly observe bottom layer, look for emerging patterns at middle layer, consider strategic implications. Emergent properties can invalidate strategic assumptions.
+
+**Example**: Microservices (operational) → Coordination overhead (tactical emergence) → Slower feature delivery (strategic failure if goal was speed)
+
+---
+
+## Quick Reference
+
+### Layer Mapping by Domain
+
+| Domain | Layer 1 (30K ft) | Layer 2 (3K ft) | Layer 3 (300 ft) |
+|--------|------------------|-----------------|------------------|
+| **Business** | Vision, mission | Strategy, objectives | Tactics, tasks |
+| **Product** | Market positioning | Feature roadmap | User stories |
+| **Technical** | Architecture principles | System design | Code implementation |
+| **Organizational** | Culture, values | Policies, processes | Daily procedures |
+
+### Consistency Check Questions
+
+| Check Type | Question |
+|------------|----------|
+| **Upward** | Do these operations implement the tactics? Do tactics achieve strategy? |
+| **Downward** | Can this strategy be executed with available tactics? Can tactics be implemented operationally? |
+| **Lateral** | Do parallel tactical choices contradict each other? Do operational procedures conflict? |
+
+### Translation Hints by Audience
+
+| Audience | Layer | Focus | Metrics |
+|----------|-------|-------|---------|
+| **CEO / Board** | 30K ft | Why, outcomes, risk | Revenue, market share, strategic risk |
+| **VP / Director** | 3K ft | What, approach, resources | Team velocity, roadmap, budget |
+| **Manager / Lead** | 300-3K ft | How, execution, timeline | Sprint velocity, milestones, quality |
+| **Engineer** | 300 ft | Implementation, details | Code quality, test coverage, performance |
+
+---
+
+## Resources
+
+### Navigation to Resources
+
+- [**Templates**](resources/template.md): Layered reasoning document template, consistency check template, cross-layer communication template
+- [**Methodology**](resources/methodology.md): Layer design principles, consistency validation techniques, emergence detection, bidirectional propagation
+- [**Rubric**](resources/evaluators/rubric_layered_reasoning.json): Evaluation criteria for layered reasoning quality (10 criteria)
+
+### Related Skills
+
+- **abstraction-concrete-examples**: For moving between abstract and concrete (related but less structured than layers)
+- **decomposition-reconstruction**: For breaking down complex systems (complements layered approach)
+- **communication-storytelling**: For translating between audiences at different layers
+- **adr-architecture**: For documenting architectural decisions across layers
+- **alignment-values-north-star**: For strategic layer definition (values → strategy)
+
+---
+
+## Examples in Context
+
+### Example 1: SaaS Product Strategy
+
+**30K (Strategic)**: "Become the easiest CRM for small businesses" (positioning)
+
+**3K (Tactical)**: "Simple UI, 5-minute setup, mobile-first, $20/user pricing, self-serve onboarding"
+
+**300 ft (Operational)**: "React app, OAuth for auth, Stripe for billing, onboarding flow: signup → import contacts → send first email"
+
+**Consistency check**: Does $20 pricing support "easiest" (yes, low barrier)? Does 5-minute setup work with current implementation (measure in practice)? Does mobile-first align with React architecture (yes)?
+
+### Example 2: Technical Architecture
+
+**30K**: "Highly available system with <1% downtime, supports 10× traffic growth"
+
+**3K**: "Multi-region deployment, auto-scaling, circuit breakers, blue-green deployments"
+
+**300 ft**: "AWS multi-AZ, ECS Fargate with target tracking, Istio circuit breakers, CodeDeploy blue-green"
+
+**Emergence**: Observed: cross-region latency 200ms → Tactical adjustment: regional data replication → Strategic clarification: "High availability within regions, eventual consistency across regions"
+
+### Example 3: Organizational Change
+
+**30K**: "Build customer-centric culture where customer feedback drives decisions"
+
+**3K**: "Monthly customer advisory board, NPS surveys after each interaction, customer support KPIs in exec dashboards"
+
+**300 ft**: "Schedule CAB meetings first Monday monthly, automated NPS via Delighted after ticket close, Looker dashboard with CS CSAT by rep"
+
+**Consistency**: Does monthly CAB support "customer-centric" (or too infrequent)? Do support KPIs incentivize right behavior (check for gaming)? Does automation reduce personal touch (potential conflict)?