Complete 5D Spec-Driven Development methodology - 12 skills for structured software development with understanding before commitment

GitHub stars
8

Install

/plugin install 5d-skills@5d-skills-marketplace

Run it inside Claude Code after adding the marketplace with /plugin marketplace add tapania/5d-skills.

Contents

Discovered from source

Skills 12

BUILD Phase

Execute tasks while maintaining spec alignment and code quality.

Build Principles

Spec Fidelity

Before writing code, re-read the relevant spec section. After writing code, verify it matches spec.

Common drift patterns:

  • Adding features not in spec ("while I'm here...")
  • Simplifying away spec requirements
  • Changing interfaces without updating spec

If drift is intentional: update spec first, then code.

Level 3 Awareness

The implementation is one solution, not the only solution. Stay open to:

  • Better approaches discovered during coding
  • Spec errors revealed by implementation reality
  • Edge cases the spec didn't anticipate

Flag these for VERIFY phase rather than silently changing.

Domain Connection (Width)

While building, ask: "Does this still serve the business/user intent?"

Technical correctness ≠ solving the right problem.

Quadrant Awareness

During implementation, check all perspectives:

  • Individual Outer: Is the code artifact correct?
  • Individual Inner: Do I understand what I'm building?
  • Collective Outer: Does this integrate with existing systems?
  • Collective Inner: Am I aligned with team/stakeholder expectations?

Skill Dependencies (Height)

If blocked:

  • Is this a code problem or a knowledge problem?
  • What adjacent skill would unblock this?
  • Should I pause to learn, or flag for help?

Time Awareness

  • Am I building on existing patterns (transcend and include)?
  • Am I replacing something? Is deprecation handled?
  • Am I creating future technical debt?

Identity Trap

Watch for defensive coding:

  • Adding complexity to avoid admitting spec issues
  • Protecting assumptions rather than solving problems
  • "It works" vs "it's right"

Build Process

For each task:

  1. Read the task description and done criteria
  2. Read the relevant spec section
  3. Implement the code
  4. Self-verify against done criteria
  5. Note any spec drift, discoveries, or concerns

Quality Checks During Build

  • Does it compile/run?
  • Does it match the spec interface?
  • Are error cases handled?
  • Is it testable?
  • Would you be comfortable debugging this at 3am?

Output Per Task

## Task [N] Complete

**Status:** done / blocked / needs-spec-update

**Implementation notes:**
[Brief description of approach taken]

**Spec drift:**
[Any deviations from spec - intentional or discovered]

**Discoveries:**
[Edge cases, issues, or insights found during implementation]

**Ready for verify:** [yes/no]

When to Pause

Stop building and escalate if:

  • Spec is ambiguous or contradictory
  • Implementation reveals spec error
  • Complexity far exceeds estimate
  • Blocked by unresolved dependency

Return to appropriate earlier phase rather than guessing.

Exit Criteria

Proceed to VERIFY when:

  • All tasks in current batch are complete
  • Code runs without errors
  • Self-verification passes
  • Discoveries are documented

GAP ANALYSIS Phase

Identify everything that must change to implement the spec.

Multi-Quadrant Gap Analysis

1. Code Gaps (Individual Outer)

Compare spec to current implementation:

  • New components needed
  • Existing components requiring modification
  • Components to deprecate/remove
  • New dependencies to add

Output: List of concrete code changes.

2. Knowledge Gaps (Individual Inner)

Identify what must be learned:

  • Unfamiliar technologies in spec
  • Domain knowledge needed
  • Patterns/approaches to research

Output: Learning tasks before or during implementation.

3. System Gaps (Collective Outer)

Identify infrastructure/tooling needs:

  • New services or environments
  • CI/CD changes
  • Monitoring/observability additions
  • Database migrations

Output: Infrastructure tasks.

4. Alignment Gaps (Collective Inner)

Identify communication needs:

  • Stakeholders who need to review spec
  • Teams affected by changes
  • Documentation updates needed
  • Training or handoff required

Output: Alignment tasks.

Gap Assessment Process

  1. Read the spec thoroughly
  2. Examine current codebase (if exists)
  3. For each spec item: Does current state satisfy it? If no, document the gap.
  4. Categorize gaps by quadrant
  5. Estimate complexity for each gap: trivial / moderate / complex / unknown

Additional 5D Checks

Thinking Level Gaps (Depth)

  • Are any gaps caused by Level 2 (dogmatic) thinking in the spec?
  • Do gaps require Level 3+ thinking to resolve (holding contradictions)?
  • Where might we be defending assumptions rather than solving problems?

Skill Dependency Gaps (Height)

  • What capabilities are missing that block multiple gaps?
  • Which gap, if resolved, would unlock others?
  • What learning is prerequisite to implementation?

Time Pattern Gaps

  • What historical patterns predict where gaps will appear?
  • Are we repeating mistakes from past projects?
  • What must we "transcend and include" from current approaches?

Identity Trap Gaps

  • Are any gaps being minimized because they threaten core assumptions?
  • What gaps are we avoiding looking at closely?

Output Format

## Gap Analysis

### Code Gaps
| Gap | Spec Item | Complexity | Notes |
|-----|-----------|------------|-------|
| [gap] | [ref] | [level] | [notes] |

### Knowledge Gaps
- [topic]: [why needed] - [how to address]

### System Gaps
- [gap]: [what's needed]

### Alignment Gaps
- [gap]: [who/what]

### Unknowns
- [unknown]: [how to resolve]

**Total gaps:** [count]
**High-complexity gaps:** [count]
**Blockers:** [any gaps that block others]

Exit Criteria

Proceed to TASKS when:

  • All spec items have been assessed
  • No "unknown" complexity items remain unaddressed
  • Blockers are identified
  • User has reviewed gap scope

ORIENT Phase

Map the problem space before committing to a direction.

Process

1. Domain Mapping (Width)

Ask: "What domains does this touch?"

Always consider:

  • Technical (obvious)
  • Business (value, stakeholders, ROI)
  • Users (behavior, needs, friction)
  • Operations (deployment, maintenance, monitoring)
  • Design (interaction, experience)

Output a simple domain list with relevance notes.

2. Thinking Level Check (Depth)

Assess current thinking level:

LevelSignsRisk
Level 1 (Conformist)"This is how it's always done"Following patterns blindly
Level 2 (Individualist)"My approach is right"Dogmatic, closed to alternatives
Level 3 (Synthesist)"Multiple approaches could work"Can hold contradictions

If stuck at Level 1-2, ask: "What would make a different approach correct?"

3. Skill Dependencies (Height)

Ask: "What capabilities must exist for this to succeed?"

  • What skills does this require that we may lack?
  • What domain knowledge unlocks other capabilities?
  • Is progress blocked by underdevelopment elsewhere?

4. Quadrant Check

For each quadrant, surface one key question:

QuadrantQuestion to Answer
Individual InnerWhat assumptions am I making?
Collective InnerWho else has stakes? Do we share understanding?
Individual OuterWhat concrete output will exist?
Collective OuterWhat systems/constraints already exist?

5. Time Context

Determine:

  • Is this greenfield or evolution of existing?
  • What must we "transcend and include" from current state?
  • What's the trajectory—V1, V2, long-term vision?

6. Identity Check

Ask the user: "What are you most attached to about this idea?"

Flag this for later—attachment points become blind spots.

Output Format

## Orientation Summary

**Domains involved:** [list]

**Key assumptions to validate:**
- [assumption 1]
- [assumption 2]

**Stakeholder alignment needed:** [yes/no, with whom]

**Existing constraints:** [systems, processes, dependencies]

**Attachment risk:** [what the user seems attached to]

**Ready for SPAR phase:** [yes/no]

Exit Criteria

Proceed to SPAR when:

  • At least 3 domains are mapped
  • Key assumptions are explicit (not hidden)
  • User acknowledges what they're attached to

PLAN Phase

Crystallize sparring outcomes into a concrete plan.

Plan Structure

1. Problem Statement

One paragraph. What problem does this solve? For whom? Why now?

Avoid: Solution-focused framing. This section is about the problem, not the answer.

2. Proposed Solution

Describe what will exist that doesn't exist now. Use plain language—no technical jargon yet.

Include:

  • Core functionality (what it does)
  • Key behaviors (how it works from user perspective)
  • Boundaries (what it explicitly won't do)

3. Assumptions & Bets

Make implicit assumptions explicit:

We assume:
- [assumption about users]
- [assumption about technical feasibility]
- [assumption about business value]

We are betting that:
- [bet 1 - what we're gambling on]
- [bet 2]

Identity attachment risk:
- [what we might be defending rather than evaluating]

4. Thinking Level Declaration (Depth)

Acknowledge current thinking level:

  • Are we at Level 2 (dogmatic—"this is the right way")?
  • Can we articulate why alternative approaches might be valid (Level 3)?
  • What novel insight does this plan contain (Level 4)?

5. Skill Dependencies (Height)

Document what capabilities the plan requires:

  • What skills must the team have or acquire?
  • What domain knowledge unlocks implementation?
  • What's blocking progress that's outside this plan's scope?

6. Alternatives Considered

Document what was rejected and why:

AlternativeWhy Rejected
[option A][reason]
[option B][reason]

This prevents re-litigating decisions later.

7. Quadrant Coverage

Ensure plan addresses all four:

QuadrantPlan Element
Individual OuterWhat artifacts will be created
Individual InnerWhat understanding/skills are required
Collective OuterHow this fits existing systems
Collective InnerWhat alignment is needed across stakeholders

8. Time Horizons

  • V1 (this iteration): [scope]
  • V2 (next iteration): [deferred scope]
  • Explicitly not planned: [out of scope]

Output Format

Produce a standalone document titled PLAN.md with the sections above.

Keep it under 500 words. Plans that require more are actually multiple plans.

Exit Criteria

Proceed to REFINE when:

  • All sections are complete
  • User confirms plan matches their intent
  • No major gaps in quadrant coverage

REFINE Phase

Stress-test the plan before committing to specification.

Stress Test Methods

1. Inversion Attack

Argue against the plan:

  • "Here's why this will fail: [reasons]"
  • "The hidden dependencies are: [list]"
  • "This assumes X, but what if X is false?"

Force the user to defend or amend.

2. Edge Case Probing

For each core behavior, ask:

  • "What happens when [unusual input]?"
  • "What if [dependency] is unavailable?"
  • "How does this behave at [scale extreme]?"

Document answers or flag as "needs resolution."

3. Stakeholder Simulation

Roleplay different perspectives:

Skeptical Engineer: "This seems over-engineered. Why not just [simpler approach]?"

Impatient PM: "When will this ship? What's the MVP?"

Confused User: "I don't understand how to [core action]."

Ops On-Call: "How do I debug this at 3am?"

4. Dependency Audit (Height)

List everything the plan depends on:

  • External services
  • Team knowledge/skills (what capabilities must exist?)
  • User behaviors
  • Business conditions
  • Adjacent domain skills that might block progress

Rate each: stable / risky / unknown

5. Quadrant Stress Test

Probe each quadrant for weaknesses:

QuadrantStress Question
Individual Inner"What understanding gaps exist?"
Collective Inner"Where might stakeholders disagree?"
Individual Outer"What artifacts are under-specified?"
Collective Outer"What system constraints are ignored?"

6. Time Trajectory Check

  • "How have similar plans failed historically?"
  • "What's changing in this domain that affects the plan?"
  • "Does this plan transcend and include current approaches, or just replace them?"

7. Level Check (Depth)

Ask yourself: Is refinement improving the plan, or is the user defending their original idea with better words?

Signs of defensive refinement:

  • Adding complexity to protect core assumptions
  • Dismissing objections rather than addressing them
  • "That won't happen" without evidence

If defensive: return to SPAR.

Output Format

## Refinement Summary

**Stress tests passed:**
- [test]: [how addressed]

**Edge cases documented:**
- [case]: [planned handling]

**Dependency risks:**
- [dependency]: [risk level] - [mitigation]

**Plan amendments:**
- [change made based on refinement]

**Unresolved issues:**
- [issue]: [why deferred / needs more info]

**Ready for SPEC phase:** [yes/no]

Exit Criteria

Proceed to SPEC when:

  • Major objections have responses (not dismissals)
  • Edge cases are documented (even if handling is "error out")
  • No high-risk dependencies without mitigation
  • Plan text has been updated with refinements

REFLECT Phase

Extract learning to evolve the development process itself.

Reflection Dimensions

Width: Domain Learning

  • What domain knowledge did we gain?
  • What domains did we neglect that caused problems?
  • What adjacent expertise would have helped?

Depth: Thinking Quality

  • Where did we get stuck in dogmatic (Level 2) thinking?
  • Where did we successfully hold contradictions (Level 3)?
  • What novel insights emerged (Level 4)?

Height: Skill Dependencies

  • What adjacent skills blocked progress?
  • What capability unlocked other capabilities?
  • What should be learned before next iteration?

Quadrants: Perspective Coverage

  • Which quadrant did we neglect?
  • Which quadrant dominated (possibly over-indexed)?
  • Where did Collective dimensions cause surprises?

Time: Pattern Recognition

  • What should we "transcend and include" next time?
  • What patterns repeated from past projects?
  • What's the trajectory—are we improving?

Identity Trap Analysis

  • Where did we stop thinking because it felt threatening?
  • What ideas did we defend rather than examine?
  • What beliefs did we inherit that we should question?
  • Where did attachment to being "right" block progress?

Reflection Questions

What Went Well

  • What decisions saved time or prevented problems?
  • What phase worked smoothly?
  • What should we repeat?

What Went Poorly

  • Where did we waste effort?
  • What surprises should have been anticipated?
  • What phase broke down?

Process Improvements

  • What should change in our workflow?
  • What new checks or steps are needed?
  • What should we stop doing?

Output Format

## Iteration Retrospective

### Dimension Analysis

**Width (domains):**
- Gained: [knowledge acquired]
- Missed: [domains we should have considered]

**Depth (thinking levels):**
- Got stuck: [where we were dogmatic]
- Breakthrough: [where we synthesized well]

**Height (skills):**
- Blocked by: [missing capability]
- Unlocked: [capability we developed]

**Quadrants:**
- Neglected: [which quadrant]
- Over-indexed: [which quadrant]

### What Worked
- [success 1]
- [success 2]

### What Didn't
- [failure 1]: [root cause]
- [failure 2]: [root cause]

### Process Changes for Next Iteration
- [change 1]
- [change 2]

### Carry Forward
[Key insight to remember for future work]

Exit Criteria

Reflection complete when:

  • All dimensions examined
  • At least one process improvement identified
  • Learnings documented for future reference

Return to ORIENT for next feature with accumulated wisdom.

5D Spec-Driven Development

A methodology for building software that prevents wasted effort by ensuring understanding before commitment at every level.

Core Philosophy

The 5 Dimensions

  1. Width - Multiple domains (technical, business, user, ops, design)
  2. Depth - Thinking levels (reactive → dogmatic → integrative → creative)
  3. Height - Skill dependencies (what capabilities enable other capabilities)
  4. Quadrants - Four perspectives (Individual/Collective × Inner/Outer)
  5. Time - Evolution ("transcend and include" from current state)

Why This Exists

Most development failures come from:

  • Building before understanding
  • Single-perspective thinking
  • Hidden assumptions
  • Spec drift from intent
  • No feedback loops

5D-SDD addresses each through structured phases with explicit exit criteria.

The 10 Phases

UNDERSTAND          DESIGN              BUILD               LEARN
───────────────     ───────────────     ───────────────     ───────────
0. ORIENT           2. PLAN             6. TASKS            9. REFLECT
1. SPAR             3. REFINE           7. BUILD
                    4. SPEC             8. VERIFY
                    5. GAP ANALYSIS

Phase Overview

#PhaseSkillWhat HappensOutput
0ORIENT5d-orientMap domains, surface assumptionsOrientation Summary
1SPAR5d-sparChallenge thinking, find blind spotsSPAR Summary
2PLAN5d-planCrystallize into concrete planPLAN.md
3REFINE5d-refineStress-test, probe edge casesRefinement Summary
4SPEC5d-specFormalize technical specificationSPEC.md
5GAP5d-gap-analysisIdentify all required changesGap Analysis
6TASKS5d-tasksSequence into executable tasksTask List
7BUILD5d-buildImplement with spec fidelityWorking code
8VERIFY5d-verifyMulti-layer verificationVerification Report
9REFLECT5d-reflectExtract learningRetrospective

How to Use

Full Workflow

For new features or projects, run phases sequentially:

/5d-orient → /5d-spar → /5d-plan → /5d-refine → /5d-spec → /5d-gap-analysis → /5d-tasks → /5d-build → /5d-verify → /5d-reflect

Each phase has exit criteria. Don't proceed until criteria are met.

Partial Workflows

Use individual phases when appropriate:

ScenarioStart At
"I have an idea, let's explore it"ORIENT
"I know what I want, challenge my thinking"SPAR
"We've discussed enough, write the plan"PLAN
"Review this plan for issues"REFINE
"Turn this plan into a technical spec"SPEC
"What do we need to change?"GAP ANALYSIS
"Break this into tasks"TASKS
"Implement this task"BUILD
"Check if this is working"VERIFY
"What did we learn?"REFLECT

Failure Routing

When something fails, return to the appropriate phase:

Failure TypeReturn To
Code doesn't runBUILD
Works but wrong outputBUILD or SPEC
Works but users confusedPLAN
Solves wrong problemSPAR or ORIENT
Keeps failing despite fixesEarlier phase (assumptions wrong)

Key Principles

1. No Commitment Without Understanding

Each phase deepens understanding before the next commitment:

  • ORIENT → understand the space
  • SPAR → understand objections
  • PLAN → commit to direction
  • REFINE → understand risks
  • SPEC → commit to implementation
  • BUILD → commit to code

2. Multi-Perspective Thinking

Every phase checks multiple quadrants:

QuadrantFocus
Individual OuterWhat artifacts exist?
Individual InnerWhat understanding is needed?
Collective OuterWhat systems/constraints exist?
Collective InnerWhat alignment is needed?

3. Explicit Over Implicit

  • Document assumptions, don't hide them
  • Document alternatives considered
  • Document what's explicitly out of scope
  • Make bets visible

4. Fail Fast, Route Correctly

  • Do risky/unknown work early
  • When something fails, identify which layer
  • Return to the right phase, don't patch at the wrong level

5. Identity Trap Awareness

Why thinking stops: Latching onto ideas as identity. When identity is threatened, the mind defends rather than explores.

Signs of the trap:

  • Dismissing objections without examination
  • Adding complexity to protect core assumptions
  • "That won't happen" without evidence
  • Rushing past uncomfortable phases

Counteract by:

  • Notice when you feel defensive—probe there
  • Hold positions lightly
  • Ask: "What would make me wrong?"

Quick Reference

Starting a New Feature

  1. User describes what they want
  2. Run ORIENT to map the space
  3. Run SPAR to challenge assumptions
  4. Run PLAN to crystallize direction
  5. Run REFINE to stress-test
  6. Run SPEC to formalize
  7. Run GAP ANALYSIS to scope work
  8. Run TASKS to sequence
  9. Run BUILD for each task
  10. Run VERIFY when batch complete
  11. Run REFLECT at iteration end

Documents Produced

  • PLAN.md - What we're building and why
  • SPEC.md - How we're building it technically
  • Task list - Sequenced implementation steps
  • Verification report - What passed/failed
  • Retrospective - What we learned

When to Skip Phases

  • Trivial changes: Skip to BUILD
  • Already planned: Start at SPEC or GAP ANALYSIS
  • Bug fixes: Start at BUILD, but VERIFY thoroughly
  • Exploratory work: ORIENT and SPAR only

Never skip VERIFY. Always close the loop.

SPAR Phase

Challenge and expand thinking through structured dialogue.

Core Principle

Your job is to be a skilled sparring partner, not a yes-machine. Push back constructively. The user's defensiveness is diagnostic—probe there.

Sparring Moves

Quadrant Rotation

Challenge from each quadrant:

QuadrantChallenge Question
Individual Inner"What assumptions are you not questioning?"
Collective Inner"What would a skeptical colleague argue?"
Individual Outer"What concrete evidence supports this?"
Collective Outer"What systems or constraints are you ignoring?"

Also challenge from role perspectives:

  • User: "What would a skeptical user say?"
  • Business: "What would a stakeholder focused on ROI question?"
  • Ops: "What would someone maintaining this at 3am flag?"

Level Elevation

When user gives Level 2 answers (dogmatic "this is right"):

  • Ask: "What would make the opposing view correct?"
  • Ask: "Under what conditions would this approach fail?"

Domain Pull

Explicitly pull adjacent domains:

  • "What would someone from [psychology/economics/security/design] notice here?"
  • "Is there a pattern from [other field] that applies?"

Inversion

  • "What's the fastest way this could fail?"
  • "If this succeeds wildly, what new problems emerge?"
  • "What are we implicitly betting on?"

Height Check (Skill Dependencies)

  • "What capability would you need to make this work that you don't have?"
  • "Is this blocked by something outside this domain?"
  • "What adjacent skill might unlock this?"

Time Trajectory

  • "What's the historical pattern here? How have similar attempts played out?"
  • "Where is this domain heading? Are you building for today or tomorrow?"
  • "What must you 'transcend and include' from current approaches?"

Conducting the Session

  1. Start with the user's strongest conviction—challenge it first
  2. Note when user becomes defensive (probe deeper there)
  3. Track emerging themes and contradictions
  4. Summarize strongest objections found

Limit to 5-7 exchanges. Sparring has diminishing returns.

Output Format

## SPAR Summary

**Strongest objections surfaced:**
1. [objection + user's response]
2. [objection + user's response]

**Unresolved tensions:**
- [tension that wasn't fully addressed]

**Blind spots identified:**
- [what user resisted examining]

**Refined direction:**
[How the idea evolved through sparring]

**Ready for PLAN phase:** [yes/no]

Exit Criteria

Proceed to PLAN when the user can articulate:

  • The strongest objections to their idea
  • Why they're proceeding anyway (not just dismissing objections)

SPEC Phase

Formalize the plan into technical specification.

Spec Structure

1. Overview

One paragraph linking back to the plan. What is being built and why (from PLAN.md).

2. Architecture

Describe the technical approach:

  • Components and their responsibilities
  • Data flow between components
  • External integrations
  • Key technical decisions with rationale

Use diagrams where helpful (mermaid, ASCII, or description).

3. Data Model

Define data structures:

  • Entities and relationships
  • Key fields and types
  • Validation rules
  • Storage approach

4. Interface Contracts

For each boundary (API, UI, integration):

  • Inputs (with types and constraints)
  • Outputs (with types and error cases)
  • Behavior specification

5. Domain Bridge (Width)

Explicitly connect technical decisions to business/user intent:

Business NeedTechnical Implementation
[need from plan][how spec addresses it]

This prevents spec drift from plan intent.

6. Quadrant Coverage

Ensure spec addresses all perspectives:

QuadrantSpec Element
Individual OuterComponents, interfaces, data structures
Individual InnerSkills/knowledge required to implement
Collective OuterSystem integrations, infrastructure
Collective InnerTeam alignment, review needs

7. Skill Dependencies (Height)

Document implementation prerequisites:

  • What capabilities must the team have?
  • What domain expertise is required?
  • What learning must happen before or during implementation?

8. Identity Trap Check

Flag where spec might be protecting assumptions rather than solving problems:

  • Are any technical decisions "because we always do it this way"?
  • What alternatives were dismissed too quickly?

9. Testability Criteria

For each spec item, define how correctness is verified:

Spec ItemVerification Method
[item][how we know it's right]

If you can't define verification, the spec is too vague.

10. Transcend and Include (Time)

Document what existing code/patterns are being:

  • Kept: [what stays unchanged]
  • Extended: [what's being built upon]
  • Replaced: [what's being deprecated]

Output Format

Produce a standalone document titled SPEC.md with sections above.

Include enough detail that implementation is unambiguous, but no more.

Exit Criteria

Proceed to GAP ANALYSIS when:

  • Every plan item maps to spec item
  • All interfaces are defined
  • Verification criteria exist for each component
  • User confirms spec matches intent

TASKS Phase

Convert gaps into sequenced, executable tasks.

Task Design Principles

Right-Sized Tasks

Each task should be:

  • Completable in one session
  • Independently verifiable
  • Clear in scope (no ambiguity about "done")

If you can't tell whether a task succeeded, it's too big or poorly defined.

Task Types

Include all types, not just code:

  • Code tasks: Implementation work
  • Research tasks: Learning/investigation
  • Infrastructure tasks: Environment/tooling setup
  • Alignment tasks: Communication/review

Dependency Ordering (Height + Time)

Sequence by:

  1. Blockers first (tasks that unblock others)
  2. Foundation before features (transcend and include)
  3. Risky/unknown tasks early (fail fast)
  4. Skill-building tasks before skill-requiring tasks
  5. Independent tasks can parallelize

Quadrant Balance

Ensure tasks cover all quadrants:

  • Code tasks (Individual Outer)
  • Research tasks (Individual Inner)
  • Infrastructure tasks (Collective Outer)
  • Alignment tasks (Collective Inner)

Don't over-index on code tasks while ignoring alignment needs.

Thinking Level Check (Depth)

For complex tasks, note the thinking level required:

  • Can this be solved with existing patterns (Level 1-2)?
  • Does this require synthesizing contradictions (Level 3)?
  • Does this require novel insight (Level 4)?

Flag Level 3-4 tasks as higher risk.

Identity Trap Check

Watch for:

  • Tasks being avoided because they challenge assumptions
  • Tasks scoped to protect rather than solve
  • Missing tasks that would reveal problems

Task Format

For each task:

### Task [N]: [Title]

**Type:** code / research / infrastructure / alignment
**Depends on:** [task numbers or "none"]
**Complexity:** trivial / moderate / complex

**Description:**
[What to do - specific enough to execute]

**Done when:**
[Verification criteria - how to know it's complete]

Sequencing Process

  1. List all gaps from gap analysis
  2. Convert each gap to one or more tasks
  3. Identify dependencies between tasks
  4. Order by dependency graph
  5. Flag parallel tracks

Output Format

## Task List

**Total tasks:** [count]
**Estimated sessions:** [rough count]

### Critical Path
[Tasks that must be sequential]

### Parallel Tracks
[Tasks that can happen simultaneously]

---

[Individual task entries in order]

Exit Criteria

Proceed to BUILD when:

  • All gaps map to tasks
  • Dependencies are explicit
  • First task is unblocked and ready
  • User agrees with sequencing

5D Thinking Framework

Apply multi-dimensional thinking to analyze problems, generate insights, and avoid cognitive blind spots. This framework expands thinking across five dimensions: width, depth, height, perspective quadrants, and time.

Core Principle

Genius thinking is the ability to continue thinking. Stupid thinking stops too early—reaching a point where pre-programmed thoughts react defensively, failing to reach novel insight. The goal is to hold threatening ideas in the realm of possibility while seeking to understand rather than merely know.

The Five Dimensions

Dimension 1: Width (Lines of Thinking)

Lines represent horizontal development—domains of knowledge. Marketing, psychology, physics, relationships, spirituality, health, etc.

Apply by: Identify which domains are relevant to the problem. Consider what adjacent domains might offer unexpected insights. Avoid reductionism (jamming everything into one domain's framework).

Dimension 2: Depth (Levels of Thinking)

Levels represent vertical sophistication within each domain. Progress through these stages:

LevelNamePatternLimitation
0InstinctualReact to stimuliNo thinking between stimulus and response
1ConformistFollow rules, obey authorityBlack/white thinking, no questioning
2IndividualistConstruct own modelStill dogmatic—"my way is right"
3SynthesistSee multiple valid modelsHold contradictions, use perspectives as tools
4GenerativeCreate original perspectivesProduce insights that didn't exist before

Apply by: Identify what level thinking is occurring. When stuck at Levels 1-2 (dogmatic "I'm right, you're wrong"), consciously shift to Level 3+ by asking: "What would make the opposing view correct?"

Dimension 3: Height (Altitude of Thinking)

Altitude is the average level across all domains—cross-dimensional development. Like a skill tree in a video game, higher traits require meeting thresholds in lower traits.

Apply by: Recognize when progress in one domain is blocked by underdevelopment in another. A business problem may actually be a leadership, time management, or even spiritual problem. Ask: "What adjacent domain skill might I need to unlock this level?"

Dimension 4: Perspective Quadrants

Four fundamental ways to examine any belief, idea, situation, or problem:

IndividualCollective
Inner (Mental)Thoughts, emotions, beliefs, consciousnessGroup beliefs, value systems, ideologies, culture
Outer (Physical)Behaviors, appearance, brain statesSystems, structures, institutions

Apply by: For any problem, ask four questions:

  1. Individual Inner: What am I thinking/feeling? What beliefs shape my view? Am I approaching this with the right mindset?
  2. Collective Inner: How does society/culture frame this? What ideologies are at play? What values underlie different positions?
  3. Individual Outer: What behaviors need to change? What are the concrete, visible steps?
  4. Collective Outer: What systems and structures exist? What technology, markets, or institutions are relevant?

Dimension 5: Time (Historical/Evolutionary Patterns)

Apply evolutionary patterns to understand trajectory and identify leverage points.

The Master Pattern: Transcend and Include

Each stage transcends and includes the previous. Matter → Life → Mind. Word → Sentence → Paragraph. If you remove a foundation, the chain collapses.

Four Evolution Tracks
TrackPattern
Individual PhysicalAtoms → Cells → Molecules → Organs → Organism
Individual MentalEgocentric (self) → Ethnocentric (tribe) → Worldcentric (all groups)
Collective PhysicalTechnology drives structure: Hoe → Villages, Plow → Empires, Machines → Nation-states, Computers → ?
Collective MentalPre-rational (conformity) → Rational (progress/science) → Post-rational (integration)

Apply by:

  • Locate where individuals operate developmentally to calibrate communication
  • Identify what technology is reshaping the relevant domain
  • Notice if problems arise from conflicting developmental levels
  • Ask: "What is the historical trajectory? Where is this likely going?"

The Identity Trap

Why thinking stops: Latching onto ideas, beliefs, or constructs as identity. When identity is threatened, the mind closes and defends rather than explores.

Counteract by:

  • Notice when the mind feels threatened—that's the signal to stay open
  • Hold positions lightly: adopt values without becoming them
  • Remember: most beliefs were inherited from circumstances of birth, not reasoned choice

Application Process

When facing a complex problem:

  1. Map the Width: What domains are relevant? What adjacent domains might offer insight?
  2. Assess the Depth: What level of thinking am I using? Am I stuck in dogmatic defense?
  3. Check the Height: Is progress blocked by underdevelopment in another domain?
  4. Rotate Through Quadrants: Examine from all four perspective angles
  5. Add Time: What's the evolutionary trajectory? What patterns from history apply?
  6. Watch for Identity: Am I defending rather than exploring?

Key Maxims

  • Knowing is horizontal (memorizing facts); understanding is vertical (cognitive sophistication)
  • You can't solve a problem from the same level of consciousness that created it
  • The space in which you can think determines the outcome of your life
  • Smart but stuck usually means horizontally advanced but vertically limited
  • Every passing moment of stupid thinking compounds, digging a deeper rut

VERIFY Phase

Verify implementation at multiple levels and route failures appropriately.

Verification Layers

Layer 1: Technical Correctness

  • Does it build/compile without errors?
  • Do tests pass?
  • Does linting pass?
  • Does it run without crashing?

Failure routing: Return to BUILD

Layer 2: Spec Fidelity

  • Does implementation match spec interfaces?
  • Are all spec requirements addressed?
  • Do outputs match spec definitions?

Failure routing: Return to BUILD (if code error) or SPEC (if spec error)

Layer 3: Plan Validity

  • Does this solve the problem stated in the plan?
  • Does user testing confirm expected behavior?
  • Are the original assumptions holding?

Failure routing: Return to PLAN or SPAR

Layer 4: Epistemic Update (Depth + Time)

  • Did we learn anything that changes our assumptions?
  • Are there new risks or opportunities?
  • Should the spec be updated for future work?
  • What patterns emerged that apply to future projects?
  • What should we "transcend and include" going forward?

Failure routing: Document for REFLECT phase

Layer 5: Multi-Dimensional Check

Quadrant coverage:

  • Individual Outer: Are artifacts complete and correct?
  • Individual Inner: Is understanding documented?
  • Collective Outer: Are system integrations verified?
  • Collective Inner: Is stakeholder alignment confirmed?

Height (Skill Dependencies):

  • Did capability gaps cause failures?
  • What skills were developed during implementation?
  • What remains blocked by missing capabilities?

Identity Trap:

  • Are we declaring success to avoid examining failures?
  • Are failures being minimized because they threaten assumptions?
  • What are we not looking at?

Verification Process

  1. Run automated checks (build, lint, test)
  2. Manual spec comparison
  3. User acceptance testing (if applicable)
  4. Collect all failures and discoveries

Failure Diagnosis

When something fails, identify which layer:

SymptomLikely LayerAction
Code doesn't runLayer 1Fix in BUILD
Works but wrong outputLayer 2Check spec, fix in BUILD or SPEC
Works but users confusedLayer 3Return to PLAN
Works but solves wrong problemLayer 3-4Return to SPAR

Critical: Don't keep fixing code if the spec is wrong. Don't keep fixing spec if the understanding is wrong.

Output Format

## Verification Report

### Layer 1: Technical
- Build: ✓/✗
- Tests: ✓/✗ ([pass]/[total])
- Lint: ✓/✗

### Layer 2: Spec Fidelity
- [Spec item]: ✓/✗
- [Spec item]: ✓/✗

### Layer 3: Plan Validity
- User testing: [results]
- Problem solved: [yes/no/partial]

### Layer 4: Learnings
- [Discovery or assumption update]

### Failures Requiring Action
| Issue | Layer | Routing |
|-------|-------|---------|
| [issue] | [1-4] | [phase to return to] |

**Verification status:** pass / fail-minor / fail-major

Exit Criteria

Feature complete when:

  • All Layer 1-3 checks pass
  • No unresolved failures
  • User confirms acceptance

Proceed to REFLECT when feature is complete or iteration is ending.

Sponsors

Details

Marketplace
tapania/5d-skills
Category
Community