Parse Arguments

Parse Arguments:

Decomposing Game Concepts with Happycapy Skills

The Parse Arguments skill, identified as map-systems on the Happycapy Skills platform, is a powerful tool for game designers seeking to organize and systematize their design process. This skill is engineered to break down a high-level game concept into granular, actionable systems while managing dependencies, prioritizing the design sequence, and generating a comprehensive index of systems. It ensures that design teams approach complex projects methodically, improving clarity and efficiency throughout the development cycle.

What Is This Skill?

The Parse Arguments skill automates the initial phases of game design decomposition. When invoked, it reads your game concept, analyzes supporting materials, and outputs a structured list of game systems with mapped dependencies and priorities. The skill supports two primary operation modes:

• Full Workflow Mode: Runs phases 1 through 5 to decompose the concept and update the systems index.
• Next System Mode: Identifies the highest-priority undesigned system from the index and hands it off for detailed design.

The skill also manages review modes, ensuring that the design process aligns with your team's current workflow requirements.

Why Use Parse Arguments?

Decomposing a game concept manually is error-prone and time-consuming. Without systematic breakdown, teams risk missing critical dependencies or duplicating design efforts. Parse Arguments provides several critical benefits:

• Consistency: Ensures every game concept is decomposed using the same rigor and standards.
• Traceability: Maps out dependencies, so all team members understand prerequisite systems.
• Efficiency: Automates the index and prioritization process, speeding up early design phases.
• Adaptability: Supports different review modes (full, lean, solo) to match team needs or production phases.

By structuring the design workflow, this skill helps maintain momentum and minimizes rework caused by overlooked requirements or unclear priorities.

How to Use Parse Arguments

Invocation Syntax

The skill can be invoked from the Happycapy command interface using the following forms:

## Full decomposition workflow (Phases 1-5)
> /map-systems

## Pick next highest-priority undesigned system (Phase 6)
> /map-systems next

## Specify a review mode
> /map-systems --review full    # Also works with lean or solo

Argument Parsing Logic

The skill parses arguments in the following way:

1. Mode Detection:
   • No argument (just /map-systems): Run full workflow.
   • next argument: Run "pick next system" workflow.
2. Review Mode Resolution:
   • If --review [full|lean|solo] is provided, use it.
   • Else, read production/review-mode.txt and use its value if present.
   • Else, default to lean.

Example pseudocode:

def parse_arguments(args):
    if "next" in args:
        mode = "next"
    else:
        mode = "full"
    if "--review" in args:
        review_mode = args["--review"]
    elif os.path.exists("production/review-mode.txt"):
        review_mode = read_file("production/review-mode.txt").strip()
    else:
        review_mode = "lean"
    return mode, review_mode

Required and Optional Inputs

• Required: design/gdd/game-concept.md
  • If missing, the skill will halt and prompt the user:
    plaintext

    No game concept found at design/gdd/game-concept.md. Run `/brainstorm` first to create one, then come back to decompose it into systems.

• Optional:
  • design/gdd/game-pillars.md (influences priorities and scope)
  • design/gdd/systems-index.md (existing index for updates)

The skill uses the following tools as needed: Read, Glob, Grep, Write, Edit, AskUserQuestion, TodoWrite, Task.

When to Use Parse Arguments

Use this skill at the following key stages:

• After brainstorming: Once a game concept has been drafted using /brainstorm, use /map-systems to initiate decomposition.
• At the start of system design: To generate or update the systems index before detailed design work begins.
• When prioritizing design tasks: Use /map-systems next to identify and begin work on the next most important system.
• When review requirements change: Specify a review mode explicitly using --review, or edit production/review-mode.txt as needed.

Important Notes

• Strict file requirements: The skill will not function without design/gdd/game-concept.md. Always ensure this file exists before invocation.
• Review mode persistence: Once a review mode is set for a session, it applies to all subsequent system gate spawns during that run.
• Dependency mapping and prioritization: The skill automates these steps, but designers should still review the generated systems index for accuracy and completeness.
• Extensibility: While optimized for the initial decomposition, this skill can be re-invoked to update the systems index as the concept evolves.

By leveraging the Parse Arguments skill, design teams can ensure their game concepts are systematically broken down, dependencies are clear, and the design workflow remains organized and efficient.