Using Claude Opus 4.5 to Build VibeUE Enhanced Input System

I just shipped a major update to VibeUE - complete support for Unreal Engine’s Enhanced Input System. What made this different? The entire feature was designed, implemented, and tested using Claude Opus 4.5 through GitHub Copilot in VS Code.

The Challenge

Unreal Engine’s Enhanced Input System is powerful but complex. It includes:

Input Actions (the “what” - Jump, Move, Look)
Input Mapping Contexts (the “when” - gameplay, menu, vehicle)
Modifiers (transform input values - deadzone, smoothing, negate)
Triggers (define activation conditions - pressed, held, released)

Building MCP tool support for all of this meant understanding the entire system deeply and creating a coherent API that AI assistants could use effectively.

The Approach: AI-Assisted Development with Opus 4.5

I used Claude Opus 4.5 in GitHub Copilot (VS Code) to drive the entire development process:

Phase 0: Design Document Generation

First, I had Opus 4.5 help create a comprehensive technical specification. The AI analyzed the Enhanced Input System architecture and produced a detailed design document covering:

Service architecture and responsibilities
API design for each action type
Error handling patterns
Integration with existing VibeUE tools

This became the blueprint for the entire implementation.

Phase 1: Core Infrastructure

With the design document as context, Opus 4.5 helped build the foundation:

Reflection-based type discovery - Dynamically find all input-related types in the Unreal project
Service layer architecture - Clean separation between MCP tools and Unreal Engine APIs
Asset management integration - Proper handling of Input Action and Mapping Context assets

The AI understood the existing VibeUE codebase structure and generated code that matched the established patterns.

Phase 2: Input Action and Mapping Services

Next came the core functionality:

Creating, configuring, and managing Input Actions
Building Input Mapping Contexts with proper binding configurations
Linking actions to player input components
Managing key bindings and gamepad mappings

Opus 4.5 generated the C++ service implementations and the corresponding MCP tool actions, maintaining consistency across the entire API.

Phase 3: Advanced Features

The final phase added the sophisticated capabilities:

Modifier Services - Deadzone, smoothing, negate, scale, swizzle, and custom modifiers
Trigger Services - Pressed, released, held, tap, pulse, chord, and combo triggers
AI Configuration Services - Natural language presets like “FPS movement” or “racing controls”

This is where Opus 4.5 really shined - it understood the relationships between modifiers and triggers and generated appropriate combinations for common game scenarios.

The Results

The Enhanced Input update adds:

Metric	Before	After
MCP Tools	9	10
Total Actions	70+	104
Enhanced Input Actions	0	34

New `manage_enhanced_input` Tool

The new tool provides complete Enhanced Input System control:

Input Actions:

list_input_actions - Discover all Input Actions in project
create_input_action - Create new Input Actions with value types
get_input_action_info - Inspect action configuration
configure_input_action - Modify action properties

Mapping Contexts:

list_mapping_contexts - Find all Input Mapping Contexts
create_mapping_context - Build new mapping contexts
add_action_mapping - Bind actions to keys/buttons
configure_mapping - Set up modifiers and triggers

Modifiers & Triggers:

list_modifier_types - Discover available modifiers
add_modifier - Apply modifiers to mappings
list_trigger_types - Discover available triggers
add_trigger - Configure activation conditions

AI-Friendly Presets:

apply_preset - Natural language input configurations
Example: “Apply FPS movement preset to PlayerMappingContext”

Testing with AI

I also used Opus 4.5 to generate comprehensive test scenarios - 130+ test prompts covering every action and edge case. The AI created realistic user requests like:

“Set up WASD movement with smooth acceleration and a small deadzone”

“Create a combo trigger that requires pressing Shift then Space within 0.5 seconds”

“Add a charged attack that triggers after holding the button for 2 seconds”

These test prompts helped validate that the tool works naturally with AI assistants.

The Workflow

Here’s what AI-assisted development looked like in practice:

Context Loading - Open relevant files and documentation in VS Code
Design Prompt - Ask Opus 4.5 to design the feature architecture
Iterative Implementation - Generate code, review, refine, test
Pattern Matching - AI learns from existing code and maintains consistency
Test Generation - Create comprehensive test scenarios
Documentation - Generate user-facing docs and examples

The key was keeping Opus 4.5 in the loop throughout - not just for code generation, but for design decisions, error handling strategies, and API design.

Key Takeaways

1. Design Documents Matter Having Opus 4.5 create a detailed design document first made implementation smoother. The AI could reference its own design when generating code.

2. Phased Approach Works Breaking the work into phases (Core → Actions/Mappings → Advanced) let the AI build on previous context without getting overwhelmed.

3. Pattern Recognition is Powerful Once Opus 4.5 understood the VibeUE code patterns, it generated consistent, idiomatic code across 30+ new files.

4. Test Generation Validates Design AI-generated test scenarios revealed edge cases and API awkwardness early in development.

5. It’s Still Collaborative The AI doesn’t replace developer judgment - it amplifies it. I reviewed every generated file, made architectural decisions, and handled the integration work.

What’s Next

With Enhanced Input support complete, VibeUE now has 10 MCP tools with 104 actions - a comprehensive toolkit for AI-assisted Unreal Engine development.

Note: These changes are currently available in the 5-7 branch for Unreal Engine 5.7 and will be merged to master soon.

Check out the full changes: GitHub Compare

This is the power of modern AI-assisted development. Claude Opus 4.5 in GitHub Copilot isn’t just autocomplete - it’s a development partner that can help design, implement, and test entire features while maintaining code quality and consistency.