marketing-shibata50/claude-code-ultimate-guide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
claude-code-ultimate-guide/docs/resource-evaluations/jon-williams-dual-instance-pattern.md
Florian BRUNIAUX 9c5d030b11 docs: add dual-instance planning pattern (Jon Williams) 
Add vertical separation pattern (planner/implementer) as complement to horizontal scaling (Boris pattern).

## Changes

**Main guide (ultimate-guide.md)**:
- New Section 9.17.1: "Alternative Pattern: Dual-Instance Planning" (~350 lines)
  - When to use (solo devs, spec-heavy, $100-200/month)
  - Setup instructions (2 Claude instances, Plans/ directory)
  - Complete workflow (5 phases: planning, review, implementation, verification, archive)
  - Comparison table (Boris horizontal vs Jon vertical scaling)
  - Cost analysis (2 instances vs correction loops)
  - Agent-ready plan best practices
  - Limitations and tips

**Workflow file (workflows/dual-instance-planning.md)**:
- Full workflow guide (~750 lines)
- Complete example (JWT auth implementation)
- Plan template (ready to copy-paste)
- Cost breakdown and decision matrix
- Troubleshooting and bash aliases

**References updated**:
- machine-readable/reference.yaml: 15 new entries
  - dual_instance_planning, dual_instance_workflow, etc.
  - Line numbers, source attribution, metadata
- guide/workflows/plan-driven.md: Link in See Also section
- README.md: Update evaluation count (46 → 47)

**Evaluation documented**:
- docs/resource-evaluations/jon-williams-dual-instance-pattern.md
  - Full methodology (fetch, analyze, challenge, fact-check)
  - Score progression (2-3/5 → 4/5 after technical-writer challenge)
  - Gap analysis, comparison, integration rationale

## Source
LinkedIn post by Jon Williams (Product Designer, UK)
Date: 2026-02-03
URL: https://www.linkedin.com/posts/thatjonwilliams_ive-been-using-cursor-for-six-months-now-activity-7424481861802033153-k8bu

Context: Transition from Cursor (6 months) to Claude Code with Opus 4.5
Pattern: Vertical separation (Claude Zero: planning/review, Claude One: implementation)
Distinction: Orthogonal to Boris pattern (vertical vs horizontal scaling)

## Stats
- Lines added: ~1,400
- Files modified: 4
- Files created: 2 (workflow + evaluation)
- References added: 15 (reference.yaml)
- Evaluation score: 4/5 (High Value)
- Integration time: ~2.5 hours

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-02-04 10:38:10 +01:00

13 KiB
Raw Blame History

Resource Evaluation: Jon Williams - Dual-Instance Planning Pattern

Evaluated: 2026-02-04 Evaluator: Claude Sonnet 4.5 Methodology: Resource evaluation workflow v1.0 (fetch → analyze → challenge → fact-check)

Resource Details

Field Value
Title Dual-Instance Claude Workflow (Planning + Implementation)
Author Jon Williams
Role Product Designer, UK
Platform LinkedIn
Date February 3, 2026
URL https://www.linkedin.com/posts/thatjonwilliams_ive-been-using-cursor-for-six-months-now-activity-7424481861802033153-k8bu
Type Personal workflow description
Context Transition from Cursor (6 months) to Claude Code

Summary

Jon Williams describes a dual-instance workflow using two simultaneous Claude Code sessions with distinct roles:

  • Claude Zero (Planner): Explores codebase, writes plans, reviews implementations, never touches code
  • Claude One (Implementer): Reads approved plans, implements features, commits changes

Key innovation: Vertical separation (planner ↔ implementer) as alternative to horizontal scaling (parallel features).

Claims:

  • "Massive improvement in quality and speed" vs Cursor
  • Interview-based planning surfaces overlooked considerations
  • Agent-ready plans (file paths + line numbers) reduce implementation time
  • Plans directory structure: Review/ → Active/ → Completed/

Evaluation Score: 4/5 (High Value)

Rationale

Initially scored 2-3/5, but technical-writer agent challenge correctly identified undervaluation:

  1. Complements existing content: Pattern is orthogonal (vertical vs horizontal scaling) to documented Boris Cherny pattern
  2. Fills audience gap: Solo devs and budget-conscious teams ($100-200/month) vs Boris pattern ($500-1K+/month)
  3. Recognized engineering pattern: Two-phase commit, separation of concerns applied to LLMs
  4. Low integration cost: ~200 lines (1 section + 1 workflow file)
  5. Testable approach: Concrete directory structure, clear workflow, replicable

Not 5/5 because:

  • Single practitioner (not validated by multiple teams yet)
  • No quantified metrics ("massive improvement" is subjective)
  • LinkedIn post (less detailed than blog post or paper)

Gap Analysis

What This Resource Covers (Novel)

Topic Covered in Resource Covered in Guide (Before) Gap Filled?
Dual-instance workflow ✅ Detailed ❌ Not mentioned ✅ Yes
Vertical separation (planner/implementer) ✅ Core concept ❌ Only horizontal scaling documented ✅ Yes
Plans directory structure (Review/Active/Completed) ✅ Explicit ❌ Only .claude/plans/ mentioned ✅ Yes
Low-budget multi-instance ($100-200/month) ✅ Implied ❌ Only $500-1K+ pattern documented ✅ Yes
Agent-ready plan structure (file paths + line numbers) ✅ Emphasized ⚠️ Not taught as best practice ✅ Yes
Human-in-the-loop planning approval ✅ Core workflow ⚠️ Implicit in /plan but not persistent ✅ Yes

What Guide Already Covered

Topic Resource Guide Coverage
/plan mode foundation ✅ Used ✅ Section 9.1, workflows/plan-driven.md
Multi-instance workflows ⚠️ Different pattern ✅ Section 9.17 (Boris: 5-15 instances)
Interview-based planning ✅ Mentioned ✅ Implicit in /plan behavior
Cost optimization ⚠️ Comparison needed ✅ Section 8.10 (but no 2-instance analysis)

Comparison Table

Pattern Dimensions

Dimension Boris Pattern (Guide Existing) Jon Pattern (This Resource)
Scaling axis Horizontal (5-15 instances, parallel features) Vertical (2 instances, separated phases)
Primary goal Speed via parallelism Quality via separation of concerns
Monthly cost $500-1,000 (Opus × 5-15) $100-200 (Opus × 2 sequential)
Entry barrier High (worktrees, 2.5K CLAUDE.md, orchestration) Low (2 terminals, Plans/ directory)
Audience Teams, 10+ devs, high-volume Solo devs, product designers, spec-heavy
Context pollution Isolated by worktrees (separate git checkouts) Isolated by role separation (planner vs implementer)
Accountability Git history (commits per instance) Human-in-the-loop (approve plans before execution)
Tooling required Worktrees mandatory Plans/ directory structure
Coordination Self-orchestrated (Boris steers 10 sessions) Human gatekeeper (move plans between directories)
Best for Shipping 10+ features/day Complex specs, quality-critical, budget <$300/month

Key insight: Patterns are complementary, not competing. Teams can use dual-instance for complex features and Boris pattern for high-volume simple features.

Integration Plan

Location

Primary: Section 9.17.1 "Alternative Pattern: Dual-Instance Planning (Vertical Separation)"

  • Inserted after: Line 12880 (Boris team patterns)
  • Before: Line 12882 (Foundation: Git Worktrees)
  • Status: ✅ Completed (2026-02-04)

Secondary: guide/workflows/dual-instance-planning.md

  • Content: Full workflow (5 phases), plan template, cost analysis, tips
  • Status: ✅ Completed (2026-02-04)

References Updated:

  • ✅ machine-readable/reference.yaml (15 new entries)
  • ✅ guide/workflows/plan-driven.md (See Also section)

Content Structure

Section 9.17.1 (~350 lines):

  • When to use dual-instance pattern
  • Setup instructions (2 instances, directory structure)
  • Complete workflow (5 phases)
  • Comparison table (Boris vs Jon)
  • Cost analysis (2 instances vs correction loops)
  • Agent-ready plan best practices
  • Limitations and tips
  • See Also links

Workflow file (~750 lines):

  • Detailed setup
  • Complete workflow with examples (JWT auth)
  • Full plan template (ready to copy-paste)
  • Cost breakdown
  • Troubleshooting guide
  • Bash aliases for efficiency

Fact-Check Results

Claim Verified Source Notes
Author: Jon Williams, Product Designer ✅ LinkedIn profile 1,086 followers, UK-based
Date: February 3, 2026 ✅ Post timestamp "17 hours ago" verified 2026-02-04
Transition: 6 months Cursor → Claude Code ✅ Post opening Direct quote
Model: Opus 4.5 ✅ Post text "Claude Code with Opus 4.5"
"Massive improvement" vs Cursor ⚠️ Post Not quantified (no metrics provided)
--plan flag or Shift+Tab ✅ Post Explicit instructions
Plans/ directory: Review/Active/Completed ✅ Post Explicitly described
Claude Zero never touches code ✅ Post "Only review it" (direct quote)
File paths + line numbers in plans ✅ Post "Agent-ready plans with specific file references"
Interview-style planning questions ✅ Post "Claude interviews you about objectives"

Confidence: High (all factual claims verified via primary source)

Limitations:

  • No quantitative metrics (% improvement, time saved, error reduction)
  • Single practitioner (not independently replicated yet)
  • Subjective assessment ("massive improvement")

Challenge Results (technical-writer Agent)

Key Critiques

  1. Score underestimation: Origin (LinkedIn vs academic paper) shouldn't devalue practical patterns
  2. Gap identification: Guide documents horizontal scaling but not vertical separation
  3. Audience gap: Solo devs ($100-200/month) underserved by Boris pattern ($500-1K+)
  4. Pattern recognition: Two-phase commit, separation of concerns = established engineering principles
  5. Cost analysis missing: Guide never compares "2 instances sequential vs 1 instance with corrections"

Aspects Initially Missed

  • Link to /plan mode: Dual-instance is extension with persistent human-in-the-loop
  • Error reduction mechanism: Two-phase commit → fewer compounding mistakes
  • Plans/ directory as workflow management: Review/Active/Completed = Kanban-style workflow
  • Non-dev audience signal: Jon is Product Designer → pattern helps non-technical users
  • Agent-ready structure: File paths + line numbers should be taught as best practice

Risk Assessment (Non-Integration)

Risk Probability Impact Mitigation
Audience gap (solo devs) 80% Medium ✅ Integrated
Pattern missing (vertical scaling) 90% High ✅ Integrated
Credibility loss 20% High ✅ Integrated + cited
User frustration (plan quality) 50% Medium ✅ Workflow file created
Cost analysis gap 70% Low ✅ Comparison table added

Conclusion: Integration necessary for guide completeness.

Recommendations

Status: ✅ COMPLETED (2026-02-04)

Actions Taken

  1. ✅ Section 9.17.1 added (~350 lines)

    • Location: Line 12884+ in guide/ultimate-guide.md
    • Content: Overview, setup, workflow, comparison, cost analysis

  2. ✅ Workflow file created (~750 lines)

    • Location: guide/workflows/dual-instance-planning.md
    • Content: Detailed workflow, plan template, examples, troubleshooting

  3. ✅ References updated

    • machine-readable/reference.yaml: 15 new entries
    • guide/workflows/plan-driven.md: Link in See Also

  4. ✅ Attribution preserved

    • Source URL cited in both locations
    • Author + date + context (Cursor → Claude transition) documented

Future Validation

Community feedback needed:

  • Do other practitioners replicate this pattern?
  • Quantitative metrics (time saved, error reduction)?
  • Alternative implementations (automation, tooling)?

Potential enhancements (future iterations):

  • Bash script to automate plan movement (Review → Active → Completed)
  • CLAUDE.md template for role enforcement
  • Integration with Tasks API for plan tracking
  • Comparison to other dual-instance patterns (if emerge)

Lessons Learned

Evaluation Process

  1. Don't undervalue non-academic sources: Practitioner experience from LinkedIn can be highly valuable
  2. Pattern orthogonality matters: Jon's pattern complements (not competes with) existing Boris pattern
  3. Audience gaps are critical: Solo devs deserve coverage even if smaller than enterprise audience
  4. Engineering principles apply: Two-phase commit, separation of concerns = transferable to AI workflows
  5. Challenge agents catch bias: Initial score (2-3/5) corrected to 4/5 via technical-writer review

Integration Quality

What worked well:

  • Comprehensive workflow file (750 lines) with ready-to-use templates
  • Cost analysis table (2 instances vs corrections) fills gap
  • Comparison table (Boris vs Jon) clarifies when to use which pattern
  • Attribution preserved (source URL, author, date, context)

What could improve:

  • Automation scripts (bash aliases provided but no full automation)
  • Community validation (single practitioner, needs replication)
  • Quantitative benchmarks (subjective "massive improvement" claim)

Related Evaluations

  • Boris Cherny workflow: Section 9.17, line 12831 (horizontal scaling pattern)
  • Plan Mode foundation: Section 9.1, line 9616 (The Trinity)
  • Team tips (Paddo.dev): Evaluation reference in reference.yaml line 456-459

Metadata

Field Value
Evaluation date 2026-02-04
Evaluator Claude Sonnet 4.5
Challenge agent technical-writer (brutal honesty mode)
Methodology version Resource evaluation workflow v1.0
Integration status ✅ Completed (same day)
Lines added (guide) ~350 (Section 9.17.1)
Lines added (workflow) ~750 (dual-instance-planning.md)
References updated 3 files (reference.yaml, plan-driven.md, this eval)
Total effort 2.5 hours (research + integration + documentation)
Score progression 2-3/5 (initial) → 4/5 (post-challenge)

Conclusion

Jon Williams' dual-instance pattern is a valuable addition to the Claude Code Ultimate Guide. It fills a documented gap (vertical separation vs horizontal scaling), serves an underserved audience (solo devs, $100-200/month budget), and applies recognized engineering principles (two-phase commit, separation of concerns) to AI workflows.

Score: 4/5 (High Value) Status: Integrated (2026-02-04) Recommendation: Monitor for community adoption and quantitative validation

Evaluation completed by: Claude Sonnet 4.5 Date: 2026-02-04 Integration completed: Same day (< 3 hours)