Multi-Platform AI Ecosystem Architect

What This Skill Does

Transforms any AI CLI into a master architect capable of designing and implementing complete ecosystem solutions. Automatically detects the current platform, analyzes requirements, recommends optimal component combinations, and generates production-ready components tailored to each platform's specific architecture and conventions.

Supported Platforms

1. Claude Code

• Directory: .claude/
• Components: Skills, Commands, Hooks, Agents, Plugins
• Triggers: /command, @agent, automatic detection
• Resource: Token-based optimization

2. Codex

• Directory: .codex/ or .vscode/codex/
• Components: Workspace config, Commands, Scripts, Extensions
• Triggers: !command, workspace automation
• Resource: Context-based optimization

3. Auggie

• Directory: .auggie/
• Components: Agents, Workflows, Integrations, Modules
• Triggers: agent:, workflow automation
• Resource: Task-based optimization

4. Kilocode

• Directory: .kilocode/
• Components: Tasks, Workflows, Tools, Configurations
• Triggers: task:, automation workflows
• Resource: Process-based optimization

5. Goose

• Directory: .goose/
• Components: Agents, Commands, Modules, Extensions
• Triggers: goose:, command modules
• Resource: Memory-based optimization

6. Gemini-CLI

• Directory: .gemini/
• Components: Contexts, Commands, Workflows, Prompts
• Triggers: gemini:, context loading
• Resource: Context-based optimization

Core Capabilities

1. Automatic Platform Detection

• Scans for platform-specific directories and files
• Detects command patterns and syntax
• Identifies platform capabilities and limitations
• Falls back to generic templates for unknown platforms

2. Multi-Platform Component Generation

• Generates platform-appropriate file structures
• Adapts component types to each platform's conventions
• Creates platform-specific configuration schemas
• Handles different resource models (tokens vs context)

3. Cross-Platform Integration

• Designs components that work across multiple platforms
• Creates migration guides between platforms
• Establishes interoperability patterns
• Handles platform-specific limitations gracefully

Platform Detection Logic

Directory-Based Detection

def detect_platform():
    platform_checks = [
        ('claude-code', ['.claude/']),
        ('codex', ['.codex/', '.vscode/codex/']),
        ('auggie', ['.auggie/']),
        ('kilocode', ['.kilocode/']),
        ('goose', ['.goose/']),
        ('gemini-cli', ['.gemini/'])
    ]

    for platform, paths in platform_checks:
        if any(os.path.exists(path) for path in paths):
            return platform
    return 'generic'

Command Pattern Detection

• Claude Code: /command, @agent delegation
• Codex: !command, workspace commands
• Auggie: agent:, workflow triggers
• Kilocode: task:, automation definitions
• Goose: goose:, module invocations
• Gemini-CLI: gemini:, context loading

When This Skill Auto-Triggers

The AI will automatically use this skill when detecting requests for:

• "create a workflow for [platform]"
• "build a [component type] for [platform]"
• "design [component] that works across multiple platforms"
• "automate this process for [platform]"
• "set up project structure for [platform]"
• "optimize my [platform] setup"
• "create templates for [platform]"
• "generate cross-platform components"
• "build ecosystem components"
• "design custom commands for [platform]"
• "create automation for [platform]"

Multi-Platform Component Generation

Platform Analysis Process

Analysis Flow:
1. Detect current platform
2. Analyze user requirements
3. Map requirements to platform-specific components
4. Generate optimized component architecture
5. Create platform-appropriate file structures

Component Mapping Matrix

Requirement	Claude Code	Codex	Auggie	Kilocode	Goose	Gemini-CLI
Automation	SKILL.md	Script	Agent	Task	Module	Workflow
User Control	Command	Command	Workflow	Config	Command	Command
Validation	Hook	Extension	Integration	Tool	Extension	Context
Specialization	Agent	Extension	Agent	Tool	Agent	Prompt

Template Adaptation Patterns

1. Directory Structure Adaptation

Template Variables:
- PLATFORM: Detected platform
- BASE_DIR: Platform-specific directory
- FILE_EXT: Platform-appropriate file extension
- SYNTAX: Platform-specific syntax (YAML, JSON, etc.)

2. Resource Budget Optimization

Resource Models:
- Claude Code: Token-based (30-600 tokens)
- Codex: Context-based (100-400 units)
- Auggie: Task-based (50-300 units)
- Kilocode: Process-based (100-500 units)
- Goose: Memory-based (100-512MB)
- Gemini-CLI: Context-based (200-2048 tokens)

3. Trigger Pattern Adaptation

Trigger Adaptation:
- Claude Code: /command, @agent, automatic
- Codex: !command, workspace, automation
- Auggie: agent:, workflow, automation
- Kilocode: task:, automation, workflow
- Goose: goose:, command, module
- Gemini-CLI: gemini:, context, workflow

Cross-Platform Workflow Examples

Example 1: Testing Workflow

User Input: "Create a testing workflow that works in Claude Code and Goose"

Generated Solution:

• Claude Code Version:
  • Skill: testing-automation (auto-trigger)
  • Command: /run-tests [type] (manual)
  • Hook: pre-commit-test-validation (blocking)
• Goose Version:
  • Agent: testing-agent (task specialist)
  • Module: test-runner.py (execution)
  • Command: goose:test (invocation)

Example 2: Documentation System

User Input: "Build documentation generation for Codex and Gemini-CLI"

Generated Solution:

• Codex Version:
  • Command: !generate-docs (workspace automation)
  • Script: doc-generator.py (generation logic)
  • Extension: docs-viewer.js (display)
• Gemini-CLI Version:
  • Context: documentation-expert (specialist)
  • Workflow: doc-generation.yaml (process)
  • Prompt: doc-template.txt (format)

Example 3: Deployment Pipeline

User Input: "Create deployment automation for Auggie and Kilocode"

Generated Solution:

• Auggie Version:
  • Agent: deployment-manager (orchestration)
  • Workflow: deploy-pipeline.yaml (process)
  • Integration: k8s-deploy.py (infrastructure)
• Kilocode Version:
  • Task: deploy-app (deployment action)
  • Workflow: ci-cd-pipeline.yaml (process)
  • Tool: infrastructure.json (config)

Platform-Specific Best Practices

Claude Code

• Focus on token efficiency and progressive loading
• Use slash commands for user-controlled workflows
• Implement hooks for quality gates and validation
• Leverage subagents for specialized tasks

Codex

• Integrate with Visual Studio ecosystem
• Use workspace configurations for team settings
• Leverage extensions for IDE integration
• Focus on automation within development workflows

Auggie

• Design agent-based architectures
• Use YAML configurations for declarative workflows
• Implement modular integration patterns
• Focus on task automation and orchestration

Kilocode

• Create task-based automation systems
• Use JSON configurations for structured data
• Implement workflow orchestration patterns
• Focus on process automation and tool integration

Goose

• Design modular agent systems
• Use Python modules for extensibility
• Implement memory-efficient workflows
• Focus on command-based interactions

Gemini-CLI

• Create context-based expertise systems
• Use YAML for structured prompts
• Implement workflow-based automation
• Focus on conversation and context management

Cross-Platform Migration

Migration Patterns

Claude Code → Codex:
  SKILL.md → workspace.json + script.py
  /command → !command + extension.js
  @agent → agent.yaml + module.py

Codex → Claude Code:
  workspace.json → AGENTS.md
  !command → /command
  extension.js → SKILL.md

Generic Template:
  Adaptable to any platform with minimal modifications
  Platform-agnostic file structures
  Universal component patterns

Interoperability Strategies

1. Adapter Components: Create wrapper components that bridge platforms
2. Shared Configurations: Use common configuration formats (YAML, JSON)
3. Standard Interfaces: Implement consistent API patterns
4. Migration Tools: Generate platform-specific migration scripts

Platform Detection and Adaptation

Auto-Detection Algorithm

def detect_and_adapt(user_input):
    # 1. Detect current platform
    platform = detect_platform()

    # 2. Analyze user requirements
    requirements = analyze_requirements(user_input)

    # 3. Adapt to platform constraints
    adapted_specs = adapt_to_platform(requirements, platform)

    # 4. Generate components
    components = generate_components(adapted_specs)

    return components

Constraint Handling

Platform Constraints:
  claude-code:
    - Token limits
    - Context window size
    - MCP integration

  codex:
    - Workspace limitations
    - IDE integration
    - Extension compatibility

  auggie:
    - Task isolation
    - Workflow complexity
    - Memory usage

  kilocode:
    - Process coordination
    - Tool availability
    - Configuration complexity

  goose:
    - Memory constraints
    - Module loading
    - Extension system

  gemini-cli:
    - Context length
    - Model limitations
    - Prompt management

Advanced Features

1. Platform-Hopping Workflows

Create workflows that span multiple platforms, using each platform's strengths:

• Claude Code: Complex reasoning and token optimization
• Codex: IDE integration and development workflows
• Goose: Memory-intensive processing
• Gemini-CLI: Context management and conversation

2. Hybrid Component Systems

Design components that combine capabilities from multiple platforms:

• Shared Configuration: Common configs stored in neutral formats
• Bridge Components: Adapters that enable inter-platform communication
• Fallback Mechanisms: Alternative approaches for platform failures

3. Progressive Enhancement

Build solutions that start simple and add complexity as needed:

• Basic: Generic templates that work everywhere
• Intermediate: Platform-specific optimizations
• Advanced: Full platform-native capabilities

Usage Examples

Cross-Platform Testing

User Input: "I need a testing solution that works in both Claude Code and Auggie"

Generated Solution:

1. Analysis: Detect current platform, generate appropriate components
2. Claude Code Version:
   • Skill: universal-testing (auto-triggering)
   • Command: /test-everything (manual)
   • Hook: validate-quality (blocking)
3. Auggie Version:
   • Agent: testing-coordinator (orchestration)
   • Workflow: testing-pipeline (process)
   • Module: quality-checker (validation)

Multi-Platform Documentation

User Input: "Create documentation that works in Codex, Goose, and Gemini-CLI"

Generated Solution:

1. Codex Components:
   • Workspace config for VS Code integration
   • JavaScript extension for display
   • Automated script for generation
2. Goose Components:
   • Agent for content processing
   • Python module for generation logic
   • Command for manual invocation
3. Gemini-CLI Components:
   • Context specialist for content expertise
   • Workflow for generation process
   • Prompts for formatting templates

Platform Migration Assistant

User Input: "Help me migrate my Claude Code setup to work with Goose"

Generated Solution:

1. Analysis Tool: Scripts to analyze existing Claude Code setup
2. Migration Generator: Automatic component conversion
3. Bridge Components: Adapters to maintain functionality
4. Validation System: Testing frameworks to ensure compatibility
5. Documentation: Migration guides and best practices

Platform-Specific Troubleshooting

Common Issues and Solutions

Claude Code

• Token Exhaustion: Implement progressive loading and caching
• Context Window Issues: Use subagents for isolation
• MCP Integration: Configure external tool access

Codex

• Extension Conflicts: Manage extension compatibility
• Workspace Issues: Resolve VS Code integration problems
• Automation Limitations: Work within IDE constraints

Auggie

• Agent Isolation: Handle context separation properly
• Workflow Complexity: Break down complex workflows
• Memory Management: Optimize task resource usage

Kilocode

• Process Coordination: Handle task dependencies
• Tool Integration: Ensure tool compatibility
• Configuration Complexity: Simplify setup processes

Goose

• Memory Constraints: Optimize for memory efficiency
• Module Loading: Handle dynamic module imports
• Extension Conflicts: Resolve dependency issues

Gemini-CLI

• Context Limits: Manage conversation length
• Model Constraints: Work within model capabilities
• Prompt Management: Optimize prompt efficiency

Future Platform Support

Extensible Architecture

The skill is designed to easily support new platforms:

1. Add Platform Detection: Extend platform checks
2. Create Templates: Build platform-specific templates
3. Define Components: Specify component types and structures
4. Implement Patterns: Create platform-specific patterns

Community Contributions

Users can contribute:

• Platform Templates: Create templates for new platforms
• Component Types: Define new component categories
• Integration Patterns: Document best practices
• Migration Guides: Share platform migration experiences

This multi-platform architect skill transforms any AI CLI into a comprehensive ecosystem builder, capable of generating optimized components for any supported platform while maintaining cross-platform compatibility and interoperability.