Step 2: Context Rules Generation

MANDATORY EXECUTION RULES (READ FIRST):

NEVER generate content without user input
ALWAYS treat this as collaborative discovery between technical peers
YOU ARE A FACILITATOR, not a content generator
FOCUS on unobvious rules that AI agents need to be reminded of
KEEP CONTENT LEAN - optimize for LLM context efficiency
ABSOLUTELY NO TIME ESTIMATES
✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config {communication_language}

EXECUTION PROTOCOLS:

Show your analysis before taking any action
Focus on specific, actionable rules rather than general advice
Present A/P/C menu after each major rule category
ONLY save when user chooses C (Continue)
Update frontmatter with completed sections
FORBIDDEN to load next step until all sections are complete

COLLABORATION MENUS (A/P/C):

This step will generate content and present choices for each rule category:

A (Advanced Elicitation): Use discovery protocols to explore nuanced implementation rules
P (Party Mode): Bring multiple perspectives to identify critical edge cases
C (Continue): Save the current rules and proceed to next category

PROTOCOL INTEGRATION:

When 'A' selected: Execute skill:bmad-advanced-elicitation
When 'P' selected: Execute skill:bmad-party-mode
PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
User accepts/rejects protocol changes before proceeding

CONTEXT BOUNDARIES:

Discovery results from step-1 are available
Game engine and existing patterns are identified
Focus on rules that prevent implementation mistakes
Prioritize unobvious details that AI agents might miss

YOUR TASK:

Collaboratively generate specific, critical rules that AI agents must follow when implementing game code in this project.

CONTEXT GENERATION SEQUENCE:

1. Technology Stack & Versions

Document the exact technology stack from discovery:

Core Technologies: Based on user skill level, present findings:

Expert Mode: "Technology stack from your architecture and project files: {{exact_technologies_with_versions}}

Any critical version constraints I should document for agents?"

Intermediate Mode: "I found your technology stack:

Game Engine: {{engine_with_version}}

Key Dependencies: {{important_dependencies_with_versions}}

Are there any version constraints or compatibility notes agents should know about?"

Beginner Mode: "Here are the technologies you're using:

Game Engine: {{friendly_description_of_engine}}

Important Notes: {{key_things_agents_need_to_know_about_versions}}

Should I document any special version rules or compatibility requirements?"

2. Engine-Specific Rules

Focus on unobvious engine patterns agents might miss:

Unity Rules (if applicable): "Based on your Unity project, I notice some specific patterns:

Lifecycle Rules: {{unity_lifecycle_patterns}}

Serialization Rules: {{serialization_requirements}}

Assembly Definitions: {{assembly_definition_rules}}

Coroutine/Async Patterns: {{async_patterns}}

Are these patterns correct? Any other Unity-specific rules agents should follow?"

Unreal Rules (if applicable): "Based on your Unreal project, I notice some specific patterns:

UPROPERTY/UFUNCTION Rules: {{macro_usage_patterns}}

Blueprint Integration: {{blueprint_rules}}

Garbage Collection: {{gc_patterns}}

Tick Patterns: {{tick_optimization_rules}}

Are these patterns correct? Any other Unreal-specific rules agents should follow?"

Godot Rules (if applicable): "Based on your Godot project, I notice some specific patterns:

Node Lifecycle: {{node_lifecycle_patterns}}

Signal Usage: {{signal_conventions}}

Scene Instancing: {{scene_patterns}}

Autoload Patterns: {{autoload_rules}}

Are these patterns correct? Any other Godot-specific rules agents should follow?"

3. Performance Rules

Document performance-critical patterns:

Frame Budget Rules: "Your game has these performance requirements:

Target Frame Rate: {{target_fps}}

Frame Budget: {{milliseconds_per_frame}}

Critical Systems: {{systems_that_must_meet_budget}}

Hot Path Rules: {{hot_path_patterns}}

Any other performance rules agents must follow?"

Memory Management: "Memory patterns for your project:

Allocation Rules: {{allocation_patterns}}

Pooling Requirements: {{object_pooling_rules}}

Asset Loading: {{asset_loading_patterns}}

Are there memory constraints agents should know about?"

4. Code Organization Rules

Document project structure and organization:

Folder Structure: "Your project organization:

Script Organization: {{script_folder_structure}}

Asset Organization: {{asset_folder_patterns}}

Scene/Level Organization: {{scene_organization}}

Any organization rules agents must follow?"

Naming Conventions: "Your naming patterns:

Script/Class Names: {{class_naming_patterns}}

Asset Names: {{asset_naming_patterns}}

Variable/Method Names: {{variable_naming_patterns}}

Any other naming rules?"

5. Testing Rules

Focus on testing patterns that ensure consistency:

Test Structure Rules: "Your testing setup shows these patterns:

Test Organization: {{test_file_organization}}

Test Categories: {{unit_vs_integration_boundaries}}

Mocking Patterns: {{mock_usage_conventions}}

Play Mode Testing: {{play_mode_test_patterns}}

Are there testing rules agents should always follow?"

6. Platform & Build Rules

Document platform-specific requirements:

Target Platforms: "Your platform configuration:

Primary Platform: {{primary_platform}}

Platform-Specific Code: {{platform_conditional_patterns}}

Build Configurations: {{build_config_rules}}

Input Handling: {{input_abstraction_patterns}}

Any platform rules agents must know?"

7. Critical Don't-Miss Rules

Identify rules that prevent common mistakes:

Anti-Patterns to Avoid: "Based on your codebase, here are critical things agents must NOT do:

Edge Cases: {{specific_edge_cases_agents_should_handle}}

Common Gotchas: {{engine_specific_gotchas}}

Performance Traps: {{performance_patterns_to_avoid}}

Are there other 'gotchas' agents should know about?"

8. Generate Context Content

For each category, prepare lean content for the project context file:

Content Structure:

## Technology Stack & Versions

{{concise_technology_list_with_exact_versions}}

## Critical Implementation Rules

### Engine-Specific Rules

{{bullet_points_of_engine_rules}}

### Performance Rules

{{bullet_points_of_performance_requirements}}

### Code Organization Rules

{{bullet_points_of_organization_patterns}}

### Testing Rules

{{bullet_points_of_testing_requirements}}

### Platform & Build Rules

{{bullet_points_of_platform_requirements}}

### Critical Don't-Miss Rules

{{bullet_points_of_anti_patterns_and_gotchas}}

9. Present Content and Menu

After each category, show the generated rules and present choices:

"I've drafted the {{category_name}} rules for your project context.

Here's what I'll add:

[Show the complete markdown content for this category]

What would you like to do? [A] Advanced Elicitation - Explore nuanced rules for this category [P] Party Mode - Review from different implementation perspectives [C] Continue - Save these rules and move to next category"

10. Handle Menu Selection

If 'A' (Advanced Elicitation):

Execute advanced-elicitation.xml with current category rules
Process enhanced rules that come back
Ask user: "Accept these enhanced rules for {{category}}? (y/n)"
If yes: Update content, then return to A/P/C menu
If no: Keep original content, then return to A/P/C menu

If 'P' (Party Mode):

Execute party-mode workflow with category rules context
Process collaborative insights on implementation patterns
Ask user: "Accept these changes to {{category}} rules? (y/n)"
If yes: Update content, then return to A/P/C menu
If no: Keep original content, then return to A/P/C menu

If 'C' (Continue):

Save the current category content to project context file
Update frontmatter: sections_completed: [...]
Proceed to next category or step-03 if complete

APPEND TO PROJECT CONTEXT:

When user selects 'C' for a category, append the content directly to {output_folder}/project-context.md using the structure from step 8.

SUCCESS METRICS:

All critical technology versions accurately documented
Engine-specific rules cover unobvious patterns
Performance rules capture project-specific requirements
Code organization rules maintain project standards
Testing rules ensure consistent test quality
Platform rules prevent cross-platform issues
Content is lean and optimized for LLM context
A/P/C menu presented and handled correctly for each category

FAILURE MODES:

Including obvious rules that agents already know
Making content too verbose for LLM context efficiency
Missing critical anti-patterns or edge cases
Not getting user validation for each rule category
Not documenting exact versions and configurations
Not presenting A/P/C menu after content generation

NEXT STEP:

After completing all rule categories and user selects 'C' for the final category, load ./step-03-complete.md to finalize the project context file.

Remember: Do NOT proceed to step-03 until all categories are complete and user explicitly selects 'C' for each!

step-02-generate.md 9.4 KB Kalıcı Bağlantı Geçmiş Ham