
Discover cloud code as an agentic tool that reads your codebase, edits files, runs commands, and integrates with development tools, turning AI brains into actionable code bodies.
Build and deploy a content tracker on GCP using Cloud Code, detailing content creation, editing, uploading, verification, and publishing, with AI-assisted workflows and done-versus-verified checks.
Install cloud code on your machine, choose between subscription and API plans, compare pro and max options, and understand token pricing and terminal or VS Code workflows.
On first launch, pick a dark theme and log in via subscription or Antropic Cloud, then configure API access, balance, and models like Opus or Sonnet.
Track cloud code usage and session limits in VS Code, weigh extra usage if needed, and follow configuration and docs to set up and work with your project.
Run local AI models for cloud code workflows with Olama, compare local versus cloud options, and fine-tune Gemma 4 for efficient code generation on GPUs.
Learn agentic workflow basics by building a hybrid app with cloud code for the back end and a ready front end, managing content through a telescope workflow.
Explore the agentic loop in cloud code, detailing think, act, and observe phases and how verification and permissions guide file creation like calculator.js and prime.js.
Learn how cloud code manages permissions and modes to control edits, planning, and automation, plus checkpoints and rewind for safe rollback of code and conversations.
Master how cloud code preserves project context with a cloud.md file to prevent cold starts and repeated file analysis by sessions.
Discover how to use cloud.md and the .cloud folder to tailor coding standards across organization, machine, project, and folder levels, with conflict resolution and lean, load-on-demand files.
Learn how to generate and test the cloud.md memory for a project, via manual or AI input, and understand how cloud memory and auto memory store project data.
Explore how slash commands offer fixed prompts for AI coding assistants, initialize projects with the init command (creating cloud.md), and manage agents and context for efficient AI-assisted development.
Master slash commands, from built-in to custom prompts, and manage memory, permissions, and context while selecting models like OPUS, SONET, or HYCO to build with AI.
Explore slash commands for managing coding sessions, including plan, diff, review, security review, rewind, rename, resume, and goal settings to track changes and tests.
Build and deploy a backend using cloud code with sub-agents, define API endpoints and seed data, and generate specs to ensure the backend follows the standards in app.js.
Create sub-agents to delegate tasks, each with its own context and tools, and return summaries to the main agent, preserving main context while tracking token use.
Run sub-agents like api extractor and seed data extractor to generate backend spec files and the api contract, monitor outcomes, and troubleshoot missing writes in cloud workflows.
Explore how to use work trees and sub-agents to run parallel experiments, such as testing sqlite vs postgres in a fast api backend, without affecting the main branch.
Use a feature-branch git workflow and uv package manager to build the backend skeleton, then implement SQLAlchemy models, Alembic migrations, FastAPI endpoints, and seed SQLite data with swagger.
Explore context engineering and context windows as you switch between Opus 4.7 and Sonnet, understanding token limits, auto-compacting, and why manual compacting preserves important details across sessions.
Explore setting up a Python backend project with uv and Alembic on GitHub. Learn to manage git workflows, create feature branches, and tailor commit messages and settings.json.
Design the backend structure from the api-contract and set up the folder structure for the api backend. Create task.py and its schemas, and use async SQLAlchemy with alembic migrations.
Connect the frontend to a real backend by replacing the mock fetch with an actual API call while preserving the API interface. Validate end-to-end operation and live updates.
Wire the frontend to the real backend by replacing mock fetch in app.js while preserving the API layer, verify connectivity, and fix frontend display to reflect backend changes.
learn to create custom commands and skills to automate repeated prompts, define endpoints via prompts, and run applications efficiently with slash commands and skill-driven workflows.
Create a skills folder inside the .plot directory, add a dedicated skill folder with a skill.md description, and restart the session to load new skills.
Learn to scaffold new fast api endpoints and write precise specs, read api contracts for the Disco workflow engine, generate route handlers and curl smoke tests, and automate endpoint workflows.
Master spec-driven development by writing a feature spec in the specs folder, then building a skill to implement it end-to-end and validating with a smoke test and acceptance criteria.
Learn how JWT security flow powers authentication and RBAC to manage admin, editor, uploader permissions, using login, access tokens, bcrypt, and local storage.
Develop a spec-driven JWT security plan by creating specs/security/securityspec.md for front-end and back-end, using bcrypt and a signed JWT with 60-minute expiry to enforce authentication and authorization.
Implement jwt security with spec-driven development by enabling authentication and authorization, updating secret keys, and leveraging rbac roles and token-based login.
Stop using AI like a search engine. Start using it like a teammate.
Most developers use AI the wrong way. They ask a chatbot for code, paste it in, and ship it, hoping it works. This Claude Code course teaches the discipline that separates engineers who ship reliable software from those who ship and hope.
You will build a real, full-stack production application with Claude Code, from your first prompt to a live HTTPS URL on Google Cloud Run. Not a toy project. A complete app with a database, JWT authentication, role-based access control, and a real deployment pipeline.
Throughout the course you will learn one core principle of professional AI development: "Done" is not the same as "Verified." The AI does the work. You do the verification.
What you will learn
Install, configure, and master Claude Code the right way
Control the agentic loop with permissions and checkpoints
Give Claude project memory using a CLAUDE markdown file
Use slash commands for precise, repeatable workflows
Run parallel agents with sub-agents and Git worktrees
Build a full FastAPI backend and wire it to a real frontend
Practice spec-driven development with custom commands and skills
Add production-grade JWT authentication and role-based access control
Connect Claude to GitHub using the Model Context Protocol (MCP)
Package your app with Docker and deploy it to Google Cloud Run
Apply the "Done vs Verified" discipline to everything you build
What you will build
Every lesson builds one real project: the Telusko Workflow Engine, a Kanban-style content production tracker with full authentication and role-based permissions.
Your finished application includes:
A FastAPI backend with async SQLAlchemy 2.0, Pydantic v2, and Alembic
A clean vanilla JavaScript frontend with no framework bloat
JWT authentication with bcrypt-hashed passwords
Server-side role-based access control across four user roles
GitHub integration through the Model Context Protocol (MCP)
A Docker container and a live deployment on Google Cloud Run
You will deploy your own version and get a real public URL you can open on any device.
Why this course is different
This is a single production project built across every lecture, not a set of disconnected tricks. You learn how the pieces fit together in a real workflow.
It is honest about the limits. You learn when to trust Claude Code, when to verify, and when to take the wheel yourself.
It treats you like an engineer. You learn to read every diff and verify every change, so you can apply these patterns to your own projects long after the course ends.
Every prompt, spec file, and command used in the course is included as a downloadable resource.
Who this course is for
Developers new to AI tools who want to learn agentic development correctly from the start
Developers already using ChatGPT, Claude, or Copilot who want to level up from AI user to AI engineer
Full-stack, backend, and Python developers who want a project-based path to mastering Claude Code
Anyone who wants a production-ready application in their portfolio
This is not a no-code course. It is for people who write code and want AI to make them far more effective.
Requirements
Basic programming familiarity (you should be comfortable reading and writing code)
Some exposure to Python, JavaScript, or the command line is helpful
A Windows or Mac computer (both are covered)
No prior experience with Claude Code or AI agents required
Ready to build?
By the end of this course you will have a real application deployed to the internet, a portfolio project you are proud of, and the discipline to build reliably with AI on your own work.
Enroll now and start building.