
Explore building a contra-style 2D game with Cloud Code as an AI-agentic partner, mastering AI-assisted workflows, the game loop, delta time, and scalable systems for a complete small-scale action game.
Check that Python is installed, install Cloud Code, sign in, and run Cloud Code; then install Visual Studio Code and add the Cloud Code extension for prompts and memory features.
discover how to install Cloud Code via OpenRouter, including creating an account, topping up credits, generating an API key, and exporting environment variables for a terminal setup.
Learn how Claude Code, a terminal agentic coding tool, reads your project, runs commands, edits files, manages Git, and uses slash plan, slash rewind, and slash doctor in VS Code.
Explore common pitfalls in game rendering, including the need for pgame.display.flip to display changes. Learn how blit order affects overlap (ground over house) and how sun.setAlpha makes the sun transparent.
Learn event-based key down and key up handling to move a player with arrow keys, switch facing images, and display current state, while comparing to state pooling with get_pressed.
Learn to use the pygame draw module to render a scene with a gradient sky, sun, hills, house, clouds, and a fence, using circle, line, polygon, ellipse, and anti-aliased lines.
Build a small Pygame game using sprites, a player and multiple coins, and master collision detection with sprite collide and group collide to increase score and respawn coins.
Explore setting up the workspace with agentic loop tools and modes and learn clod code commands such as read, grep, bash, and edit.
Learn how agentic loops in cloud code turn vague prompts into Python by reading settings.json, planning steps, and iteratively verifying with edit tools and bash, guided by the log panel.
Cloud Code automatically selects default tools for reading and editing, read, glob, grep, grab, edit; diffs appear before changes, while the task tool researches separately and returns only the summary.
Learn to use Claude Code's permission modes—supervised for beginners, plan mode for in-depth previews, and auto mode with a built-in safety classifier—to safely build code like a pygame requirements file.
demonstrates setting up a camera and layer rendering order for a pygame-based game, including reading settings.json and designing main.py with AllSprites and a game class.
Understand the basic game loop and asset loading in the game class with Pygame. Learn how the camera and parallax sky layers use offsets for seamless rendering and proper y-sorting.
Learn how to diagnose and recover from write tool failures when building games with Claude Code and agentic AI, including file checks, permissions, and path handling in main.py.
Explore permission modes—supervised, auto mode, edit manually, and plan—and learn delta time and frame rate independence through cloud code, showing dt and fps in main.py with diffs before applying.
Master four essential slash commands for agentic ai: help opens documentation, memory loads clod.md, and usage or status track usage; clear resets history while preserving memory, compact summarizes sessions.
Explore subagents to inspect game asset structures with an object-oriented approach; learn to use glob and bash to map sprite assets and verify frame naming for robust loading.
Explore code diffs and the edit tool to refactor a blink effect into its own method, enforcing single responsibility and clearer animation logic in game code.
Learn to use grep to verify conventions across Python files, including convert_alpha transparency and list_dir sort checks. See how manual checks reveal line numbers and set up automated hooks next.
Learn how maps are built from tmx files, tilesets, and global IDs, with layered rendering from background to top details, and how to load tiles and player and enemy entities.
Explore auto memory in cloud code, where hashed project data lives in the .cloud folder to build cross-session knowledge, notes, and memory.md for improved problem solving.
Plan mode guides designing the player class by reusing entity inheritance, applying gravity, handling horizontal and vertical collisions with moving platforms, and preparing for death and game over.
Review the prompt's thought process through physics, input, and collision to build a game. Explain how the dry principle guides ground movement and wall collisions with player and tile data.
Implement a custom skill to fire bullets and fix movement and animation issues in cloud code using markdown files with front matter in the commands folder to create slash commands.
Create a custom skill in the clod project to auto-generate a PGameSprite subclass for a bullet, using write and edit tools, following Claw.md conventions, with a compile check.
Using slash commands, create a new sprite class and generate bullet.py, add muzzle flash animation, review diffs, and implement a kill method to prevent memory leaks and enable collision masking.
Learn how to implement the chute callback signature to ensure consistent argument order across all firing entities, preventing silent misbehavior and embedding the dry principle in game shooting systems.
Integrate the shooting system by wiring the player's callback to spawn bullets and fire animations from main.py, with tests validating the shared callback interface and settings injection.
Learn to implement post tool usage hooks in a claud project, create the hooks folder, and configure quality checks and settings.local.json to enforce rules like convert_alpha and self.kill.
Learn how pre tool usage hooks protect settings.json by blocking write and edit actions, and why hook coverage must anticipate tool chain paths like bash to ensure safeguards.
Learn Claude interactive mode vs headless mode, initiate sessions, run prompts, view code diffs, and generate structured JSON outputs for CLI workflows and automated pipelines.
Learn to build and run validation scripts with Cloud Code that derive asset expectations from actual code, automating checks for graphics, tmx, and audio resources.
Create a procedural level generator with Claude Code that outputs JSON for platforms, enemies, and power-ups across easy, medium, and hard modes, with an optional seed and slash command.
Create and run architecture tests validating entity.pi and settings.json, settings injection, role and layer keys, collision handling, and kill calls to prevent memory leaks, with six tests passing.
Explore the first context pattern in cloud code with emphasis on prompt engineering, exploration steps, and efficient token costs through an explore sub-agent, summary, and implementation.
Explore checkpointing, or rewind, which saves the CLAUD session state, including conversation history and file changes. Use the rewind slash command to restore code or conversation to a previous point.
Master the loop slash command to run a prompt at intervals such as every 30 seconds, with 10 iterations and real-time test feedback, enabling cron jobs for continuous integration pipeline.
Let's be honest. Most developers have a graveyard of unfinished projects.
You start a game, get through the basics, and then hit a wall — the codebase gets messy, motivation drops, and the project dies in a folder somewhere. Sound familiar?
This course fixes that. You'll build a complete, fully playable Contra-style 2D action platformer in Python — and you'll build it the way professional developers actually work today: with Claude Code and AI agents doing the heavy lifting on boilerplate, code review, and repetitive tasks so you can focus on the parts that actually matter.
This is not a Pygame tutorial. This is not an AI tools demo.
It's a real project, built from scratch, using both at the same time.
You'll set up Claude Code on day one, configure it to understand your entire codebase, create specialized agents with defined roles, and watch an AI pipeline write a feature, review it, flag problems, and fix them automatically. Meanwhile the game you're building gets more complete every single session.
By the end, you'll have shipped something real. Something you're proud to put in a portfolio.
What You'll Build
A fully playable action platformer with:
Responsive player movement, jumping, ducking, and 8-direction shooting
Enemy patrol AI driven by an idle → alert → attack state machine
Multi-phase boss battles that change patterns as health drops
Procedurally generated levels, no manual level design required
Particle effects, screen shake, parallax scrolling, and smooth sprite animation
Tile-based maps, minimap, HUD, health bars, and a power-up system
Every value tuned from a single config file: no magic numbers anywhere
An automated test suite that keeps your architecture clean as the project grows
What You'll Learn About Claude Code
This is where the course gets interesting. You won't just use Claude as a fancy autocomplete. You'll build a proper AI development environment:
Write a CLAUDE md that gives your AI full awareness of your project's architecture, conventions, and goals so every suggestion it makes actually fits your codebase
Create specialized agents with defined roles: one writes features, one reviews them, one validates them
Build slash commands that scaffold new sprite classes, generate levels, and create boilerplate in seconds
Set up hooks/skills that run automated quality checks on every single AI action before it touches your code
Use planning mode to have Claude design the architecture of a feature before a single line gets written
Configure memory so Claude retains full project context across sessions — no re-explaining yourself every time you open a new chat
Lock down permissions and settings so your agents only touch what they're supposed to
What You'll Learn About Pygame
And the game dev side is just as deep:
A layered rendering system with proper background, midground, and foreground separation
Delta-time physics so your game runs identically on every machine at every frame rate
A reusable Entity base class with animation, health, invincibility frames, and timers baked in
A state machine pattern for enemy AI that's clean, readable, and easy to extend
Tiled map integration for loading collision layers, decorative tiles, and camera tracking
A projectile system with pooling, directional movement, and automatic lifetime cleanup
Procedural level generation that places platforms, enemies, and pickups algorithmically
Sprite optimization with convert_alpha() so your game actually runs fast
You know basic Python. You've maybe done a tutorial or two. You want to build something complete, learn how AI tools actually fit into a real workflow, and walk away with skills you can use on the next project — and the one after that.
You don't need game dev experience. You don't need to know anything about Claude Code. You just need to show up and build.