# Game Server Stability Optimization

> Dedicated Game Server Stability & Performance Optimization — Expert Game Server Reliability & Performance Engineering analysis harness. Use this skill whenever the user mentions game servers, multiplayer infrastructure, server optimization, dedicated game hosting, cloud gaming architecture, server scaling, load balancing for games, DDOS mitigation for games, game server monitoring, observability…

- **Type:** Skill
- **Install:** `agentstack add skill-dungnotnull-game-server-stability-optimization-agent-skill-game-server-stability-optimization-agent-skill`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [dungnotnull](https://agentstack.voostack.com/s/dungnotnull)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [dungnotnull](https://github.com/dungnotnull)
- **Source:** https://github.com/dungnotnull/game-server-stability-optimization-agent-skill

## Install

```sh
agentstack add skill-dungnotnull-game-server-stability-optimization-agent-skill-game-server-stability-optimization-agent-skill
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Game Server Stability & Performance Optimization Skill

## Skill Registration & Metadata

**Skill ID**: `game-server-stability-optimization`  
**Version**: 1.0.0  
**Domain**: Game Server Reliability & Performance Engineering  
**Primary Use Case**: Production-grade game server architecture analysis, stability optimization, and performance engineering

### Registration Schema

```json
{
  "skill_id": "game-server-stability-optimization",
  "name": "Game Server Stability & Performance Optimization",
  "version": "1.0.0",
  "registration_date": "2026-07-15",
  "domain": "game-server-reliability-performance-engineering",
  "capabilities": [
    "architecture-analysis",
    "stability-optimization", 
    "performance-engineering",
    "autoscaling-design",
    "ha-failover-planning",
    "ddos-mitigation",
    "observability-design",
    "evidence-backed-analysis"
  ],
  "tools_required": [
    "WebSearch",
    "WebFetch", 
    "Read",
    "Write",
    "Bash",
    "Skill"
  ],
  "dependencies": {
    "python": ">=3.11",
    "packages": ["requests", "feedparser", "beautifulsoup4", "scholarly", "pyyaml"]
  }
}
```

## Skill Resolution & Execution

### Resolution Process

When `/game-server-stability-optimization` is invoked, the skill resolver:

1. **Language Detection**: Analyzes input for Vietnamese/English markers
2. **Requirement Extraction**: Identifies object, scope, constraints, timeframe
3. **Context Assembly**: Gathers available inputs and target audience
4. **Execution Planning**: Routes through 6-step harness with quality gates

### Execution Flow

```
USER INPUT
    ↓
[PRE-FLIGHT: Language Detection + Requirement Extraction]
    ↓
[STEP 1: sub-gather-requirements] → Structured requirements
    ↓
[STEP 2: sub-evidence-collector] → Evidence bundle
    ↓
[STEP 3: sub-core-analysis] → Architecture & optimization plan
    ↓
[STEP 4: sub-knowledge-updater] → Academic evidence
    ↓
[STEP 5: sub-advisor] → Risk-disclosed synthesis
    ↓
[STEP 6: Quality Gate Review] → Verification & delivery
```

## Input/Output Schemas

### Input Schema

```json
{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "User's analysis request"
    },
    "language": {
      "type": "string",
      "enum": ["en", "vi"],
      "description": "Detected language preference"
    },
    "context": {
      "type": "object",
      "properties": {
        "game": {"type": "string"},
        "expected_ccu": {"type": "integer"},
        "regions": {"type": "array"},
        "cloud": {"type": "string"},
        "constraints": {"type": "object"}
      }
    },
    "analysis_type": {
      "type": "string",
      "enum": ["architecture", "optimization", "troubleshooting", "planning"]
    }
  },
  "required": ["query"]
}
```

### Output Schema

```json
{
  "type": "object",
  "properties": {
    "report": {
      "type": "object",
      "properties": {
        "metadata": {
          "type": "object",
          "properties": {
            "date": {"type": "string", "format": "date"},
            "analyst": {"type": "string"},
            "language": {"type": "string"},
            "domain": {"type": "string"},
            "version": {"type": "string"}
          }
        },
        "executive_summary": {"type": "string"},
        "inputs_scope": {"type": "object"},
        "evidence_collected": {"type": "array"},
        "analysis_scorecard": {"type": "object"},
        "action_plan": {"type": "array"},
        "academic_evidence": {"type": "array"},
        "disclosure": {"type": "string"},
        "recommendation": {"type": "object"}
      }
    },
    "quality_gates": {
      "type": "object",
      "properties": {
        "universal_gates": {"type": "array"},
        "domain_gates": {"type": "array"},
        "passed": {"type": "boolean"},
        "limitations": {"type": "array"}
      }
    },
    "degradation_level": {
      "type": "integer",
      "minimum": 0,
      "maximum": 4
    }
  }
}
```

## Sub-Skill Registry

### Available Sub-Skills

| Sub-Skill | Purpose | Input Schema | Output Schema |
|-----------|---------|--------------|---------------|
| `sub-gather-requirements` | Extract analysis parameters | `RawUserInput` | `StructuredRequirements` |
| `sub-evidence-collector` | Fetch authoritative data | `StructuredRequirements` | `EvidenceBundle` |
| `sub-core-analysis` | Core domain analysis | `GameServerContext` | `AnalysisScorecard` |
| `sub-knowledge-updater` | Query knowledge base | `TopicKeywords` | `AcademicEvidence[]` |
| `sub-advisor` | Synthesize recommendations | `AnalysisEvidence` | `FinalRecommendation` |

### Sub-Skill Resolution

Sub-skills are resolved via the skill registry:

```python
def resolve_sub_skill(skill_name: str) -> SkillDefinition:
    """Resolve sub-skill by name with validation"""
    skill_path = f"skills/{skill_name}.md"
    return load_and_validate_skill(skill_path)
```

## Quality Gate Validation

### Gate Enforcement

All outputs must pass 10 quality gates before delivery:

**Universal Gates (U1-U6)**:
- U1: ≥3 sources cited, ≥1 academic/authoritative
- U2: Safety/risk/limitation disclosure present
- U3: Evidence hierarchy stated per source (Tier 1-4)
- U4: Language matches user preference
- U5: Output uses declared template
- U6: Every claim traceable to ≥1 source

**Domain Gates (G1-G4)**:
- G1: Architecture & tick rate stated
- G2: Autoscaling + HA/failover designed
- G3: DDOS/abuse mitigation present
- G4: Observability (metrics/SLO/alerts) present

### Validation Schema

```json
{
  "quality_gates": {
    "universal": [
      {
        "gate_id": "U1",
        "check": "source_count >= 3 && academic_count >= 1",
        "auto_fix": "fetch_from_knowledge_base",
        "enforcement": "append_sources"
      },
      {
        "gate_id": "U2", 
        "check": "disclosure_section_present",
        "auto_fix": "prepend_disclosure",
        "enforcement": "block_until_present"
      }
    ],
    "domain": [
      {
        "gate_id": "G1",
        "check": "architecture_defined && tick_rate_stated",
        "auto_fix": "state_architecture_tick",
        "enforcement": "flag_limitation"
      }
    ]
  }
}
```

## Tool Definitions

### Core Tools

| Tool | Purpose | Usage Pattern |
|------|---------|---------------|
| `WebSearch` | Real-time domain news | Search authoritative sources |
| `WebFetch` | Scrape documentation | Fetch specific standards/docs |
| `Read` | Read project files | Load knowledge base, configs |
| `Write` | Write project files | Update knowledge, save outputs |
| `Bash` | Execute Python scripts | Run knowledge pipeline |
| `Skill` | Invoke sub-skills | Sequential harness execution |

### Tool Execution Handlers

```python
class ToolExecutionHandler:
    """Handles tool execution with validation and error handling"""
    
    def execute_tool(self, tool: str, params: dict) -> ToolResult:
        """Execute tool with validation"""
        if not self.validate_tool_params(tool, params):
            raise ToolValidationError(f"Invalid params for {tool}")
        
        try:
            result = self.tools[tool].execute(params)
            return self.validate_tool_result(tool, result)
        except Exception as e:
            return self.handle_tool_error(tool, e)
```

## Error Handling & Graceful Degradation

### Degradation Levels

| Level | Condition | Behavior |
|-------|-----------|----------|
| 0 | All sources reachable | Full analysis |
| 1 | Some primary sources fail | Use secondary + flag |
| 2 | Most live sources fail | Knowledge base only |
| 3 | Required input missing | Flag unavailable |
| 4 | All sources + KB fail | Emit limitation notice |

### Error Recovery

```python
class ErrorHandler:
    """Handles errors with graceful degradation"""
    
    def handle_error(self, error: Exception, context: dict) -> ErrorResult:
        """Handle error with appropriate recovery strategy"""
        recovery_map = {
            SourceTimeout: "retry_alternate_source",
            InvalidInput: "request_user_confirmation",
            MissingInput: "proceed_with_available",
            KnowledgeBaseMiss: "websearch_gap_fill"
        }
        
        strategy = recovery_map.get(type(error))
        return self.apply_strategy(strategy, error, context)
```

## Configuration Management

### Config Schema

```json
{
  "config": {
    "domain": {
      "knowledge_sources": ["arxiv", "semantic_scholar", "aws_docs"],
      "quality_tiers": {
        "tier_1": ["peer_reviewed", "standards_orgs"],
        "tier_2": ["cloud_providers", "industry_leaders"],
        "tier_3": ["technical_blogs", "case_studies"],
        "tier_4": ["general_news", "forums"]
      }
    },
    "execution": {
      "timeout_seconds": 30,
      "max_retries": 3,
      "degradation_threshold": 0.5
    },
    "knowledge_pipeline": {
      "crawl_schedule": "weekly",
      "dedup_method": "sha256",
      "scoring_weights": {
        "recency": 0.3,
        "relevance": 0.5,
        "citation": 0.2
      }
    }
  }
}
```

## Monitoring & Observability

### Metrics Collection

```python
class SkillMetrics:
    """Collects execution metrics"""
    
    def track_execution(self, execution: dict) -> None:
        """Track skill execution metrics"""
        metrics = {
            "timestamp": datetime.now().isoformat(),
            "skill_version": "1.0.0",
            "execution_time_ms": execution["duration"],
            "tokens_used": execution["tokens"],
            "quality_gates_passed": execution["gates_passed"],
            "degradation_level": execution["degradation"],
            "user_language": execution["language"]
        }
        self.emit_metrics(metrics)
```

### Logging Schema

```json
{
  "log_entry": {
    "timestamp": "string",
    "level": "INFO|WARN|ERROR",
    "skill": "game-server-stability-optimization",
    "step": "string",
    "message": "string",
    "context": {
      "user_query": "string",
      "language": "string",
      "gates_checked": ["string"]
    }
  }
}
```

## Knowledge Pipeline Integration

### Knowledge Base Structure

```
SECOND-KNOWLEDGE-BRAIN.md
├── Core Methods & Frameworks
├── Key Papers (with DOIs)
├── State-of-the-Art Techniques  
├── Data Sources & References
├── Evaluation Frameworks
├── Self-Update Protocol
└── Update Log
```

### Crawl Pipeline

```python
# tools/knowledge_updater.py
class KnowledgeUpdater:
    """Automated knowledge crawl pipeline"""
    
    def crawl_academic_sources(self) -> List[Paper]:
        """Crawl academic databases with deduplication"""
        
    def crawl_news_sources(self) -> List[Article]:
        """Crawl domain news feeds"""
        
    def score_and_filter(self, items: List) -> List:
        """Composite scoring: recency + relevance + citation"""
        
    def deduplicate(self, items: List) -> List:
        """SHA256-based deduplication"""
```

## Testing & Validation

### Test Schema

```json
{
  "test_scenarios": [
    {
      "id": "standard-analysis",
      "name": "Standard Game Server Analysis",
      "input": {
        "query": "Analyze dedicated server setup for FPS game with 10K CCU",
        "language": "en"
      },
      "expected_outputs": {
        "architecture_defined": true,
        "tick_rate_stated": true,
        "quality_gates_passed": ["U1", "U2", "U3", "U4", "U5", "U6", "G1", "G2", "G3", "G4"]
      }
    }
  ]
}
```

## Version History

| Version | Date | Changes |
|---------|------|---------|
| 1.0.0 | 2026-07-15 | Initial production release with full 8-file contract |

## License

MIT License - See LICENSE file for details

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [dungnotnull](https://github.com/dungnotnull)
- **Source:** [dungnotnull/game-server-stability-optimization-agent-skill](https://github.com/dungnotnull/game-server-stability-optimization-agent-skill)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-dungnotnull-game-server-stability-optimization-agent-skill-game-server-stability-optimization-agent-skill
- Seller: https://agentstack.voostack.com/s/dungnotnull
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.