shape-task

Name: shape-task
Availability: InStock
Author: Afovea

Decompose ambiguous game development requests into structured requirements and execution chunks.

Updated May 18, 2026

Search Tags:#strategy #decomposition #pipeline #vertical-slice #game-development #task-shaping

Ready to run

npx skills add https://github.com/afovea/game-dev-skills --skill shape-task

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: shape-task
Source: https://github.com/afovea/game-dev-skills/tree/main/plugins/game-team/skills/shape-task
Command: npx skills add https://github.com/afovea/game-dev-skills --skill shape-task

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the ambiguity and scope creep inherent in game development by forcing a structured, pre-implementation decomposition of any feature or fix request.

Core Features & Use Cases

Requirement Decomposition: Converts vague requests into functional, non-functional, and feel-based requirements.
Strategic Planning: Generates an implementation strategy including risk assessment, technical dependencies, and validation steps.
Chunking: Breaks large tasks into manageable, testable vertical slices to ensure high-reliability execution.
Use Case: When a designer asks for a new parry mechanic, this skill clarifies the feel, defines the technical constraints, and chunks the work into animation, input handling, and VFX tasks.

Quick Start

Invoke the shape-task skill followed by your rough feature request to receive a full implementation plan and execution chunks.

Frequently Asked Questions about shape-task

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I decompose ambiguous game development requests into actionable tasks?▼

Decomposing ambiguous game development requests involves breaking down rough ideas into functional, non-functional, and feel-based requirements. This process clarifies technical constraints and chunks the work into manageable, testable vertical slices for implementation.

What is the best way to prevent scope creep when planning game features?▼

Preventing scope creep requires forcing a structured, pre-implementation decomposition of any feature or fix request. Converting vague requests into clear requirements and implementation strategies ensures scope control and technical clarity before coding begins.

How do I break down a large game development task into testable vertical slices?▼

Breaking down large tasks into testable vertical slices requires chunking the work into manageable execution segments based on a strategic implementation plan. This ensures high-reliability execution by validating requirements against engine-agnostic standards.

Does this task shaping approach work for both new game mechanics and bug fixes?▼

Yes, this task shaping approach operates effectively on features, systems, content, and bug fixes. It uniformly decomposes requests into structured requirements, implementation strategies, and actionable execution chunks regardless of the request type.

How do I generate an implementation strategy with risk assessment for a game feature?▼

Generating an implementation strategy involves assessing risks, identifying technical dependencies, and defining validation steps for the requested feature. The strategy provides a final execution prompt to guide downstream implementation tasks.

When do I need to validate game development requirements against engine-agnostic standards?▼

Validating requirements against engine-agnostic standards is necessary when seeking technical clarity and scope control prior to implementation. This ensures that the generated execution chunks remain testable and high-reliability across different environments.