Designing and Implementing an Automated Game Build Generator with Large Language Model Skills
This article presents a Skill-based approach to automated strategy-game build generation. It combines structured expert knowledge, dynamically retrieved game data, and an AI Agent that is required to generate and compare multiple build options. The approach reduces manual trial and error while also highlighting the limitations of offline, theory-driven recommendations that cannot be validated through live gameplay.
1. Project Background and Core Idea
In strategy games, a build is often determined by multiple dimensions, including faction, unit composition, spells, and hero roles. Manually designing a complete build can be time-consuming and heavily dependent on experience. If this experience can be taught to a reasoning-capable large language model, the model can enumerate and compare different options on behalf of the player, significantly reducing the cost of trial and error.
This is the purpose of the automated build generator. The author’s accumulated build-design methodology is packaged into a Skill file that can be loaded by a large language model. Users only need to describe what they want in natural language. The AI then retrieves relevant data, generates several possible approaches, compares them, and selects the most suitable result.
2. Overall Architecture
The solution consists of four layers:
Data layer: Numerical data for units, spells, equipment, and other game elements is maintained in a publicly available community database. Because the game does not provide an API, the generator retrieves the latest data from an external source whenever it runs. This allows it to naturally accommodate version updates. In theory, the same approach can also support comparisons involving test or historical versions.
Skill layer: The build methodology is written as a structured Skill file. It includes core principles such as unit roles, resource curves, and power-spike timing. A Skill is essentially a domain-specific operating manual for the model. After reading it, the model can follow the intended build-design process.
Execution layer: A general-purpose AI Agent loads the Skill and performs the task. In practice, stronger models tend to understand build logic more accurately. However, even a top-tier model may need approximately 20 minutes to complete the full process of generating and evaluating multiple options. The workflow is deliberately required to produce at least three substantially different builds before performing a cross-comparison.
Interaction layer: Users describe their requirements in natural language without needing to understand the underlying data sources or workflow orchestration.
3. Key Design Principles for Skill Packaging
3.1 Injecting Experience Instead of Listing Rules
The Skill does not simply contain rigid numerical tables. It encodes the author’s way of thinking about build design: select the primary combat unit first, add supporting units to cover its weaknesses, and then verify the resource curve and timing.
By describing a repeatable reasoning process rather than providing fixed answers, the model can generalize when user requirements change.
3.2 Enforcing Multi-Option Evaluation
The Skill imposes a hard requirement that every generation produce at least three differentiated builds and explain the trade-offs between them.
This reduces the risk and randomness of returning a single unexamined answer. It also allows users to understand how different strategies balance strengths, weaknesses, resources, and timing.
3.3 Supporting Iterative Refinement
The Skill can be updated by recording the model’s current understanding. After a long conversation with the model, newly established insights can be consolidated into the Skill file.
The author has used this incremental teaching process to continuously improve the Skill. It provides a relatively low-cost way to turn personal experience into an reusable, structured knowledge asset.
4. Prompting and Usage Techniques
- Explicit constraints can significantly change the output. For example, users can require that a build include a flying mount or a chariot-like mount.
- When the model does not understand a special mechanic, a strong instruction such as “generate a build that includes this mechanic” can guide it to explore that direction.
- The workflow can run with a web-based model available under a free usage allowance, but users should consider usage limits and differences in file-reading capabilities. Some free access points may not be able to read Skill attachments and therefore require an environment with suitable file-parsing support.
5. Current Limitations and Boundaries
The limitations of this approach must be stated clearly:
Theory without live validation: Because the game has no API, the model cannot test its recommendations in actual gameplay. A build may be theoretically consistent but ineffective in practice. This is a common limitation of offline generation systems.
Mechanics outside the model’s knowledge: Special mechanics involving operations, economic interactions, and other systems that strongly depend on practical experience have not yet been incorporated. The model does not fully understand these areas.
Incomplete coverage: Hero equipment, governor traits, unit modifications, and other dimensions are not currently covered because systematic data is unavailable or there are too many special cases. Recommendations in these areas should be treated as reference material only.
Default strategic pattern: The default output follows a conventional approach built around one primary unit type supported by heroes. Builds involving two coordinated unit types are attempted only occasionally.
6. Conclusion
This project demonstrates how the combination of Skill packaging, external data retrieval, and mandatory multi-option evaluation can be applied to a specialized domain.
A structured Skill file preserves individual expert knowledge. A dynamic data source helps the system adapt to version changes. Workflow constraints reduce the randomness of model output by requiring the model to generate and compare multiple alternatives.
Although the lack of live validation means that all recommendations still require human review, the approach provides a practical way to make an experienced player’s build-design knowledge available to a broader audience. The same pattern can be applied to other strategy systems or configuration problems that provide publicly available numerical data.
