Orchestre

Appearance

/generate-implementation-tutorial ​

Generate an intelligent orchestration guide for building any production-ready application, leveraging existing documentation without duplicating content.

Overview ​

The /generate-implementation-tutorial prompt creates an intelligent implementation guide that references your existing documentation rather than duplicating it. Instead of generating massive documents with embedded specifications, it creates a concise roadmap that tells Claude exactly where to find information and how to implement it correctly. This reference-based approach maintains a single source of truth while providing precise execution guidance.

  • Purpose: Implementation tutorial generation
  • Category: Meta Commands
  • Type: Dynamic prompt
  • MCP Tools: None (prompt-based)

Prompt Adaptation ​

This prompt dynamically adapts based on:

Context Discovery ​

  • Documentation Architecture: Maps all project_docs/ specifications
  • Command Availability: Discovers template-specific and core commands
  • Project Philosophy: Extracts unique architectural principles
  • Technology Stack: Adapts to chosen frameworks and services

Intelligence Patterns ​

  • Assesses documentation quality (specs vs explanations ratio)
  • Creates dependency graphs between documentation sections
  • Identifies parallelizable vs sequential tasks
  • Generates fallback strategies for missing docs
  • Adapts complexity ratings to team context

Reference-Based Approach ​

  • Never duplicates documentation content
  • Points to specific sections and line numbers
  • Maintains single source of truth
  • Breaks complex specs into focused steps

Memory Integration ​

This prompt actively uses and updates distributed memory:

Reads From ​

  • project_docs/*.md - All specification documents
  • .orchestre/prompts.json - Available prompts
  • CLAUDE.md - Project philosophy and patterns
  • .orchestre/patterns/*.md - Established patterns

Creates/Updates ​

  • [ProjectName]_IMPLEMENTATION_TUTORIAL.md - The orchestration guide
  • .orchestre/documentation-map.md - Doc quality assessment
  • .orchestre/dependency-graph.md - Task relationships
  • CLAUDE.md - Adds project philosophy section

Memory Evolution ​

  • Each execution improves documentation mapping
  • Tracks which references were most useful
  • Builds knowledge of effective orchestration patterns
  • Documents discovered gaps for future improvement

When to Use ​

Use this prompt when:

  • Starting a new project and need a comprehensive implementation guide
  • Want a step-by-step tutorial with exact commands to execute
  • Need to understand the full scope before beginning development
  • Planning resources and timeline for a project MVP
  • Creating documentation for team collaboration

How It Works ​

1. Requirement Analysis ​

The command analyzes your project description to extract:

  • Project type and architecture model
  • Core features and value proposition
  • Target audience characteristics
  • Technical requirements and scale

2. Documentation Discovery ​

The command performs intelligent documentation mapping:

  • Checks for project_docs/ directory and catalogs all specification files
  • Assesses documentation quality and completeness
  • Maps sections to specific implementation areas
  • Identifies any gaps that need manual discovery

3. Command Index Loading ​

Efficiently discovers available commands:

  • First checks .orchestre/prompts.json for available prompts
  • Falls back to reading .claude/commands/ if index not found
  • Notes template-specific command suffixes
  • Only reads full prompt definitions when detailed parameters needed

4. Tutorial Generation ​

Creates a reference-based implementation guide:

  • Each step references specific documentation sections
  • Includes precise navigation instructions (file + section numbers)
  • Provides time estimates and complexity ratings
  • Identifies parallelizable tasks
  • Includes fallback strategies for missing docs

Usage ​

Basic Usage ​

bash
/generate-implementation-tutorial "A B2B application for managing social media content calendars with team collaboration, post scheduling, and analytics"

With Detailed Requirements ​

bash
/generate-implementation-tutorial "Build WorkflowOS - a chat-first cognitive operations system using Cloudflare Edge, Durable Objects for stateful AI agents, and MakerKit as the foundation. See requirements.md for full details."

Tips for Best Results ​

  1. Be Specific: Include technical preferences, architectural decisions, and unique features
  2. Reference Docs: If you have requirements documents, mention them in your description
  3. State Constraints: Mention any specific technologies, deployment targets, or limitations
  4. Describe Philosophy: Include design principles or unique approaches (e.g., "chat-first", "no dashboards")

Generated Output Structure ​

The command creates a [ProjectName]_IMPLEMENTATION_TUTORIAL.md file with:

Progress Tracker ​

  • Interactive checkboxes for each phase
  • Real-time progress visibility
  • Step completion tracking

Philosophy & Architecture ​

  • Project-specific principles
  • Architectural decisions
  • Technical constraints
  • Unique patterns

Orchestration Patterns ​

  • Sequential: Steps that must complete in order
  • Parallel: Steps that can run simultaneously
  • Iterative: Steps with implement → test → refine cycles
  • Dependent: Steps requiring multiple prerequisites

Reference-Based Steps ​

Each step includes:

markdown
##### Step X.Y: [Task Name]
**Documentation**: 
- Primary: `project_docs/[doc].md` sections X.X-X.X
- Supporting: `project_docs/[doc].md` section "Topic"
- Context: `CLAUDE.md` for patterns

**Your Prompt**:

/command "1. Read sections X-Y 2. Note critical details 3. Implement as specified 4. Validate against section Z"


**Complexity**: High/Medium/Low
**Time Estimate**: X hours
**Parallelizable**: Yes/No
**Dependencies**: [Previous steps]

**If Documentation Missing**:
- Fallback discovery approach
- Commands to understand patterns
- What to document

Example: Reference-Based Tutorial ​

markdown
# Implementation Tutorial: TaskFlow Application

## Progress Tracker
- [ ] Phase 1: Foundation (0/4 steps)
- [ ] Phase 2: Core Features (0/6 steps)
- [ ] Phase 3: Advanced Features (0/5 steps)

## Documentation Architecture
**Available Specifications**:
- `project_docs/database-schema.md` - Complete schema (sections 1-12)
- `project_docs/ui-architecture.md` - UI patterns (sections 1-8)
- `project_docs/api-design.md` - API specs (sections 1-10)
- `project_docs/security-model.md` - Security requirements (sections 1-6)

**Documentation Quality**: High (80% specifications, 20% explanations)

## Phase 1: Foundation

### Step 1.1: Database Implementation
**Documentation**:
- Primary: `project_docs/database-schema.md` sections 3.1-3.8
- Supporting: `project_docs/security-model.md` section 2 "RLS Policies"

**Your Prompt**:

/add-database-table-makerkit-nextjs "

  1. Read complete schema from database-schema.md sections 3.1-3.8
  2. Pay attention to:
    • Multi-tenant pattern in section 3.2
    • RLS policies in section 3.7
    • Index strategy in section 3.8
  3. Implement exactly as specified
  4. Validate against expected schema in section 3.9"

**Complexity**: High - 20+ interconnected tables
**Time Estimate**: 3-4 hours
**Parallelizable**: No - all features depend on schema
**Dependencies**: Environment setup complete

**If Documentation Missing**:
- Fallback: `grep -r "CREATE TABLE" . | head -20`
- Discovery: `/discover-context` on similar projects
- Document: Create database-schema.md with findings

Traditional Enterprise Example ​

markdown
# Implementation Tutorial: FitnessTracker Plus

## Executive Summary
**Vision**: Personal fitness tracking app with social features and AI coaching
**Timeline**: 5 weeks to MVP
...

Best Practices ​

1. Prepare Documentation First ​

For optimal results:

  • Create detailed specifications in project_docs/
  • Use clear section numbering (1.1, 1.2, etc.)
  • Focus on concrete specs over high-level descriptions
  • Aim for 70%+ specification content

2. Review Generated References ​

Before executing:

  • Verify documentation sections exist
  • Check that references are accurate
  • Ensure specifications are complete
  • Update docs if discrepancies found

3. Track Progress Actively ​

  • Update checkboxes as you complete steps
  • Note any documentation issues encountered
  • Create tasks for doc updates needed
  • Maintain single source of truth

4. Handle Missing Documentation ​

  • Use fallback discovery approaches
  • Document findings for future use
  • Update specs before team encounters same issue
  • Flag critical gaps for immediate attention

Integration with Other Commands ​

The implementation tutorial references these Orchestre commands:

  • /create - Project initialization
  • /orchestrate - Requirement analysis
  • /add-feature - Feature implementation
  • /setup-stripe - Billing configuration (if applicable)
  • /add-team-feature - Multi-tenancy (if applicable)
  • /security-audit - Security review
  • /deploy-production - Deployment

Key Features ​

Reference-Based Approach (v3.6.2) ​

  • Single Source of Truth: Never duplicates documentation content
  • Precise Navigation: References specific sections and line numbers
  • Cognitive Load Management: Breaks complex specs into focused steps
  • Documentation Integrity: Maintains authoritative project docs

Intelligent Discovery ​

  • Prompt System: Uses .orchestre/prompts.json for dynamic prompt loading
  • Documentation Mapping: Catalogs all available specifications
  • Quality Assessment: Evaluates documentation completeness
  • Dependency Graph: Maps relationships between docs

Adaptive Execution ​

  • Complexity Ratings: Helps allocate appropriate time
  • Parallelization Info: Identifies independent tasks
  • Fallback Strategies: Handles missing documentation
  • Progress Tracking: Interactive checkboxes for visibility

Philosophy ​

This command embodies Orchestre's evolution:

  • Reference Over Duplication: Points to truth rather than copying it
  • Discovery Over Assumption: Maps what exists before planning
  • Orchestration Over Generation: Guides execution intelligently
  • Adaptation Over Prescription: Adjusts to documentation reality

The command transforms from a "content generator" to an "intelligent orchestrator" that:

  • Discovers your documentation architecture
  • Creates precise execution references
  • Manages cognitive load through focused steps
  • Maintains documentation as single source of truth

Direct Invocation ​

This is a dynamic prompt that Claude executes directly - no file installation needed:

bash
# Simply type the command
/generate-implementation-tutorial "B2B application for team collaboration"

# Claude will:
# 1. Discover all project documentation
# 2. Map documentation to implementation areas
# 3. Load available commands efficiently
# 4. Generate reference-based orchestration guide
# 5. Create intelligent execution roadmap

Common Issues ​

Documentation Not Found ​

If the prompt reports missing documentation:

  1. Check that project_docs/ directory exists
  2. Ensure files have clear section numbering
  3. Verify specifications are detailed enough
  4. Consider creating docs before generating tutorial

Command Index Missing ​

If .orchestre/prompts.json not found:

  1. Run /initialize to create project structure
  2. Or use /create for new projects
  3. The prompt will fall back to reading individual files

Generic Tutorial Generated ​

If tutorial seems generic rather than specific:

  1. Provide more detailed requirements
  2. Reference existing documentation
  3. Include architectural preferences
  4. Specify unique constraints

Built with ❤️ for the AI Coding community, by Praney Behl

Copyright © 2025 Orchestre