Building a 1024 Web Game with Spec‑Driven Development and GitHub Copilot

Vibe Coding—continuous chat with an AI to generate code—offers fast prototyping but often leads to unclear requirements, tangled architecture, and unreliable outcomes. To address these issues, the article introduces Spec‑Driven Development (SDD), a methodology that adds a formal specification layer (requirements, design, tasks, and feedback) on top of AI‑assisted coding.

SDD emerged as a response to the shortcomings of ad‑hoc AI coding. Its core idea is to keep the rapid start of Vibe Coding while inserting a specification phase that defines what to build (What) and why (Why), followed by a design phase, task breakdown, and iterative feedback. This improves code quality, maintainability, and consistency.

Several tools support SDD, notably Kiro (an Agent IDE) and the spec‑coding‑mcp protocol. The focus of the tutorial is the GitHub Spec Kit, an open‑source collection of prompts, scripts, and templates that integrates with GitHub Copilot. The repository (https://github.com/github/spec-kit) had version 0.45 on 2025‑09‑20 and was later updated to 0.0.54.

The Spec Kit directory contains: .github/prompts: prompt files that follow Copilot’s format. scripts/: automation scripts for branch creation and template copying. templates/: document templates for requirements, design, and tasks. memory/constitution.md: a project constitution that defines immutable principles.

After installing GitHub Copilot in VS Code or IDEA, the workflow proceeds with four main commands:

/specify – describe the desired feature (What) and its purpose (Why). Example used: “Build a 1024 game where tiles merge to reach 1024, grouped by date, draggable on the homepage, no nested albums.”

/plan – suggest the technology stack and architecture. The example plan chose Vite, minimal dependencies, native HTML/CSS/JS, and a local SQLite database for metadata.

/tasks – generate an executable task list from the plan.

/implement – let the AI produce the code for each task.

The author demonstrates two iterations of this process. In the first iteration, the AI produces a complete HTML page, CSS stylesheet, and JavaScript logic for the 1024 game. The resulting directory structure is shown in screenshots, and the game runs with keyboard and touch controls.

After reviewing the first version, the author refines the specification, runs /specify again, and repeats the planning and task generation steps. The second iteration adds a more polished UI and additional documentation. The Spec Kit automatically backs up the first version, allowing easy comparison.

Key code excerpts (translated to English) are included:

// 1024 web game main logic skeleton
const BOARD_SIZE = 4;
let board = [];
let score = 0;
function initBoard() {
  board = Array.from({ length: BOARD_SIZE }, () => Array(BOARD_SIZE).fill(0));
  addRandomTile();
  addRandomTile();
  renderBoard();
}
// ... (other functions for tile addition, movement, touch handling, UI dialogs)

The HTML file defines the game container, board, score display, and control buttons. The CSS uses CSS variables for light/dark themes and responsive grid layout. The JavaScript handles board initialization, random tile generation, move logic, keyboard and touch input, and UI updates.

Images throughout the article illustrate the specification workflow, the generated files, and the final game UI. The author notes that the AI now handles the transformation from vague ideas to concrete requirements, design documents, task lists, and finally implementation, while the human only provides high‑level intent and reviews each stage.

In the concluding section, the article summarizes SDD principles:

Intent‑driven development : define “What” before “How”.

Detailed, constrained specifications : specifications are actionable, not vague.

Multi‑stage refinement : spec → plan → tasks → implement, allowing iterative correction.

AI as an executor : the AI follows the structured documents rather than writing code arbitrarily.

A side‑by‑side comparison chart highlights how Vibe Coding relies on continuous AI chat, whereas Spec‑Driven Development introduces explicit artifacts that guide the AI and reduce uncertainty.

Overall, the tutorial shows that Spec‑Driven Development, supported by GitHub Spec Kit and Copilot, can reliably produce a functional web game while keeping the development process transparent and maintainable.