Intensive Course: 20 Hours (10 Sessions x 2 Hours)
This program is designed for those who want to move beyond simply "chatting" with AI and start using it as a full-scale engineering team. We teach Vibe-coding—a methodology where you act as the architect and conductor, while autonomous AI agents handle all the technical heavy lifting.
During the course, we will deploy and configure your development "cockpit":
- Orchestrators: Antigravity, Claude Code (CLI).
- Environment: VS Code + Windsurf / Cursor.
- Optimization: MCP (Model Context Protocol).
- Infrastructure: RunPod, Vast.ai (GPU rental), Docker.
- Interfaces: Bolt.new, Lovable.
We are currently accepting applications for the live-mentor cohort. To participate:
- Fill out the form: Application Form
- Join the Telegram Group: AI School EN
- Introduce yourself: Once you've filled out the form, drop a message in the group!
- Theory (30 min): What is Vibe-coding? Logic over syntax. Tool overview.
- Hands-on (90 min):
- Installing VS Code, Claude Code, and Antigravity.
- Git Baseline: Initializing your first repo. Why "Save Points" (commits) are your life insurance.
- Creating the first project folder.
- Command: "Make me a simple resume page with a theme toggle."
- Result: A working local page, configured environment, and your first commit.
- Theory (30 min): Describing structure vs. "make it pretty." Choosing the "form": SPA, Multi-page, or Chrome Extension?
- Hands-on (90 min):
- Working in Bolt.new or Lovable.
- Creating a visual prototype.
- Exporting code to the workspace.
- Result: A finished visual prototype and a clear technical direction.
- Theory: Applying token knowledge to optimize workflow. MCP (Google, DBs) and Agent Skills (Expert roles). Designing "Data Schemas" (JSON/TypeScript interfaces) for agents.
- Practice: Using compact context. Setting up
.claudignoreand.envfor security. Connecting external tools via MCP. Installing real skills (e.g., telegram-bot-builder). - Result: Reducing costs by 5–10x, secure environment, and an agent with expert capabilities.
- Theory (30 min): CLI agent capabilities. Managing dependencies.
- Practice (90 min):
- Task: "Build the core logic."
- Refactoring: Commands for cleanup and optimization. "Dialogue with code": how to fix specific details without breaking everything.
- Result: Project gains functionality and clean, structured code.
- Theory: Transformer architecture, tokens and Attention mechanism. Context window limits, token economics, and caching (70–90% cost savings). Three levels of AI: LLMs, Reasoning models, Agents. Context Engineering: why context matters more than prompts. Three knowledge sources: in-context learning, RAG, fine-tuning.
- Practice: AI security: prompt injection, jailbreaking, data leakage. OWASP Top 10 for LLM. API vs self-hosted model overview.
- Result: A clear mental map of the AI landscape, cost optimization strategies, and security awareness.
- Theory: Agentic engineering. Roles: "Architect," "Developer," "Tester." Single-agent to multi-agent systems.
- Practice: Running Antigravity to coordinate multiple AIs. Automated bug discovery and security checks.
- Result: A functioning "mini-studio" of AI agents running on your machine.
- Theory: When APIs become too expensive. Overview of RunPod and Vast.ai. Transition from pay-per-token to hourly GPU rental.
- Practice: Renting a GPU server for $0.30/hr. Deploying DeepSeek-V3 or Llama-3. Teaching agents to use your own server as "Brain."
- Result: A personal, unlimited AI coder on a remote server.
- Theory: Infrastructure as Code: controlling servers via natural language and SSH. Containerization with Docker (images, containers, volumes).
- Practice: "Log into my server, install Docker, set up GitHub Actions for auto-deploy." Monitoring and self-healing applications.
- Result: Your project is live and updates automatically on every push.
- Theory: Project structure: monolith, microservices, monorepo. Deployment environments: dev, staging, production. Testing: unit, integration, E2E.
- Practice: Monitoring & observability: logs, metrics, alerts. Release process: from PR to production.
- Result: Understanding of production-grade architecture and the full release pipeline.
- Final assembly: combining UI, logic, and infrastructure. Adding analytics (PostHog) and error tracking (Sentry).
- Peer Testing: Testing each other's projects and collecting feedback. Quick fixes with AI agents.
- The Pitch: 3-minute project presentation. The Defense: Technical Q&A on architecture and AI's role.
- Result: Graduation with a fully functional application, digital certificate, and the skills to build any IT project in the future.
The requirement for completing the school is a fully functional product created independently using AI agents.
Note: Mentors support you until a successful submission. If the project isn't working, the mentor provides additional consultations until the goal is reached.
- 0% Boring Theory: We don't teach Python or JavaScript syntax.
- 100% Control: You learn to manage the tools that write the code for you.
- Efficiency: You learn how to spend pennies on tokens where others spend thousands of dollars.
- Calendar-based and group training: You'll have additional responsibility, which will prevent you from procrastinating.
- Real results: The training won't end until you create a real product that you can sell or use yourself.
Built for those who want to build the future, not just watch it happen.