⚡ ASJPrompts & Studio · AI Developer Bootcamp · Module 12

AI CODING AGENTS
& DEV ENVIRONMENTS

Most people have never understood VS Code Agent Mode, Claude Code, Google Antigravity, Cursor, Windsurf, or GitHub Copilot properly. That changes today.

8

Tools Mastered

10

Missions

1000

XP to Earn

∞

Coding Power

🌐 What is Vibe Coding? — The Concept Behind Everything

The Definition

Vibe coding is a software development practice where you describe what you want to build in natural language, and AI generates the code automatically.

The term was coined by Andrej Karpathy (co-founder of OpenAI) in February 2025 — and it became Collins Dictionary's Word of the Year 2025.

Karpathy's original quote: "There's a new kind of coding I call vibe coding, where you fully give in to the vibes, embrace exponentials, and forget that the code even exists."

The Numbers

$4.7B

Market 2026

92%

US Devs Daily AI

25%

YC '25 95% AI Code

41%

Code AI-Written '24

The shift: In 2024, AI assistants wrote 41% of all code (~256 billion lines). This number is expected to double in 2025. Google CEO Sundar Pichai confirmed that over 25% of Google's code is now AI-generated before human review.

🎚️ The Vibe Coding Spectrum — Three Modes

AUTOPILOT MODE

Fully trust AI output. Accept code without review. Best for: rapid prototypes, hackathons, weekend projects. Risk: security debt, unmaintainable code.

Beginner-FriendlyHigh Risk

COPILOT MODE

AI accelerates you but you still write and review. Best for: daily development, feature implementation, pair programming. Balance of speed and quality.

IntermediateBalanced

AGENT MODE

AI executes multi-step tasks autonomously. You orchestrate, define goals, review results. Best for: large refactors, system design, complex pipelines. This module's focus.

AdvancedPro-Grade

🔄 What Changes For You as a Developer

OLD ROLE — Line Writer

×

Write every line manually

Syntax, boilerplate, debugging — all on you

×

Context-switch constantly

Stack Overflow, docs, IDE, terminal — all separate

×

Slow iteration cycles

Hours from idea → working prototype

NEW ROLE — Agent Orchestrator

1

Define goals, not lines

Describe outcomes — agents handle implementation

2

Review and direct

You make architectural decisions, agents execute

3

Orchestrate multiple agents

Parallel agents on parallel tasks = 10× throughput

The Anthropic finding: In a study of 400,000 Claude Code sessions (Oct 2025–Apr 2026), people make most planning decisions (what to do) while Claude makes most execution decisions (how to do it). The greater domain expertise you bring, the more work Claude does per instruction.

The Evolution of Software Development

From manually writing every character to autonomous agents that plan, code, test, and deploy entire systems. Five stages. One inevitable direction.

01

🖊️ Manual Coding

Every character written by hand. Developers hold full mental models of the entire codebase. Deep understanding required before any output.

Era: 1950s → 2020 · Still relevant for critical systems

02

💡 Autocomplete & Snippets

IDEs learn your patterns and suggest completions. GitHub Copilot (2021) brought line-level AI suggestions directly into the editor flow.

Era: 2021–2023 · GitHub Copilot launch changed everything

03

🤝 AI Copilots — Chat-Based Assistance

Conversational AI inside the IDE. Cursor, Copilot Chat, CodeGPT — ask questions, get explanations, generate functions via natural language. Multi-file awareness arrives.

Era: 2023–2024 · Context windows expanded, IDE integrations matured

04

🤖 Coding Agents — Autonomous Execution

Agents read the codebase, plan a sequence of actions, execute them, run tests, and fix failures — all without you guiding each step. This is where we are now.

Era: 2025–2026 · Claude Code, Antigravity 2.0, Cursor Agent Mode

The Agent Loop

1

Read

Maps entire codebase structure

2

Plan

Proposes multi-step action sequence

3

Execute

Edits files, runs commands

4

Verify

Runs tests, reads errors, iterates

Real Results (2025)

• Stripe deployed Claude Code to 1,370 engineers. One team completed a 10,000-line Scala→Java migration in 4 days (estimated 10 engineer-weeks)

• Claude Code reached $1B ARR in 6 months — fastest in enterprise software history

• 25% of YC Winter 2025 companies had 95%+ AI-generated codebases

05

🚀 Autonomous Development — Full Pipeline

Agent teams that design architecture, implement, test, deploy, and monitor — end to end. Prompt → Production. Human role becomes product manager + safety reviewer.

Era: 2026+ · Antigravity parallel agents, Claude sub-agents, agentic engineering

VS Code Deep Dive

The world's most popular editor — and the foundation of most AI coding tools. Cursor, Antigravity IDE, and Windsurf are all VS Code forks. Master this and you master them all.

01

🖥️ The VS Code UI — What Every Panel Does

Explorer · Editor · Terminal · Extensions · Source Control

+25 XP

📁 Explorer (Ctrl+Shift+E)

File tree for your project. AI agents read this to understand codebase structure. Keep it clean — agents navigate it like humans do.

✏️ Editor (Multi-tab)

Where code lives. AI agents make edits here. Use Split Editor to review diffs side-by-side when an agent makes multi-file changes.

🖥️ Terminal (Ctrl+`)

Integrated shell. Coding agents run commands here — npm install, pytest, git operations. Keep it open when running agents.

🧩 Extensions (Ctrl+Shift+X)

Install AI coding tools here. GitHub Copilot, Continue.dev, Cline — all ship as VS Code extensions with full editor integration.

🌿 Source Control (Ctrl+Shift+G)

Git integration built-in. Stage, commit, diff, branch — all visible. AI agents use git to track their own changes and create atomic commits.

💬 Chat Panel (Copilot)

When Copilot is installed, a dedicated chat panel appears. This is where you write task prompts for Copilot's Agent Mode (2025 feature).

02

🤖 VS Code Agent Mode — Enabling & Using It

GitHub Copilot's Agent Mode turns VS Code into an autonomous coding system

+35 XP

What Agent Mode is: Instead of responding to single prompts, VS Code Agent Mode runs a loop — Copilot plans a task, executes it across multiple files, runs terminal commands, reads errors, and iterates — all inside your VS Code workspace.

ENABLING AGENT MODE IN VS CODE

# Step 1: Install GitHub Copilot Extension Extensions → Search "GitHub Copilot" → Install # Requires active GitHub Copilot subscription ($10/mo) # Step 2: Enable Agent Mode Ctrl+Shift+P → "GitHub Copilot: Enable Agent Mode" # Or: Click the Copilot icon → Switch to "Agent" tab # Step 3: Open the Chat Panel Ctrl+Alt+I → Opens Copilot Chat sidebar # Step 4: Describe your task (not a question — a goal) "Implement a user authentication flow with JWT tokens. Create login, register, and refresh token endpoints. Add middleware to protect existing routes. Write tests for all new functions." # Agent will: read codebase → plan → execute → verify

✓ Agent Mode CAN

• Edit files across the entire workspace
• Run terminal commands (npm, pip, etc.)
• Create new files and directories
• Read error messages and self-correct
• Access GitHub issues and PRs

✗ Agent Mode CANNOT

• Access the internet by default
• Remember previous sessions
• Act without user approval (by default)
• Understand your business requirements
• Replace architectural thinking

Key setting: In Agent Mode, enable "Auto-approval" carefully. It lets the agent run commands without asking each time — faster, but riskier. Start with it OFF until you trust the agent's judgment.

03

🧩 Must-Have Extensions for AI Development

The extensions that turn VS Code into a pro AI coding environment

+30 XP

🔗 Continue.dev

OPEN SOURCE · BYOK

Bring your own API key. Supports Claude, Gemini, GPT, local models. Free, privacy-first. 5M+ installs. Best Copilot alternative for teams needing vendor independence.

🤖 Cline

OPEN SOURCE · AGENT-GRADE

Full autonomous agent in VS Code. Plans, executes, reads errors, iterates. Works with Claude, GPT-4. Top-rated for agentic workflows. 5M+ installs on Marketplace.

🐙 GitHub Copilot

$10/MO · ENTERPRISE-READY

The enterprise standard. 20M+ users. SOC 2 compliant. Agent Mode (2025), multi-model support (Claude Sonnet 4.6, GPT-5). Best for companies already on GitHub Enterprise.

🔧 Error Lens

FREE · DEBUGGING AID

Shows errors and warnings inline in the editor. Essential when working with agents — you see exactly what errors the agent is trying to fix in real-time.

PROJECT MEMORY FILE — .cursorrules / CLAUDE.md / AGENTS.md

# This file tells AI agents about YOUR project # Place at project root: CLAUDE.md (Claude Code), .cursorrules (Cursor), AGENTS.md (general) ## PROJECT IDENTITY Name: [Your Project Name] Stack: React 18 + TypeScript + Node.js + PostgreSQL Style: Functional components, no class components Tests: Jest + React Testing Library — write tests for all new features ## ARCHITECTURE RULES - Components go in /src/components — one file per component - Business logic only in /src/hooks or /src/services — never in components - API calls only through /src/api/client.ts — never fetch() directly - State management: Zustand only — no Redux, no Context API for global state ## CODE STANDARDS - TypeScript strict mode — no 'any' types, no implicit any - All async functions must handle errors with try/catch - Comments only for WHY, never for WHAT (code is self-documenting) - Max function length: 40 lines — extract if longer ## WHAT YOU MUST NEVER DO - Never install new packages without asking me first - Never modify .env files - Never delete files — use git instead - Never skip error handling

Google Antigravity

Google's agent-first development platform. Launched November 2025 as a VS Code fork with agents at the center. Version 2.0 launched at Google I/O 2026 as a full ecosystem. Free to start.

🌌 What Is Antigravity?

Google Antigravity started as an agent-first IDE — a VS Code fork where AI agents have their own dedicated surface separate from the editor, instead of living in a sidebar. Version 2.0 is now a full platform: Desktop App + CLI + SDK + Managed Agents API.

The name: A Python easter egg — import antigravity opens XKCD #353 ("Python makes impossible things effortless"). The literal promise: removing gravity from development.

Nov '25

v1.0 Launch

Free

Base Tier

3.5F

Default Model

3

Model Options

Gemini 3.5 Flash (default)Claude Sonnet 4.6GPT-OSS-120B

01

⬇️ Installation & First Launch

Download, install, and authenticate on macOS, Windows, or Linux

+30 XP

Antigravity IDE

Antigravity CLI

Desktop App 2.0

ANTIGRAVITY IDE — INSTALLATION

# Download Antigravity IDE (VS Code fork) Visit: antigravity.google → Download for your OS # Available: macOS, Windows, Linux # Step 1: Launch — IDE opens (familiar VS Code interface) # Step 2: Sign in with Google account (top right) # Step 3: Choose your primary model in Agent Manager: Settings → Agent Manager → Model → Gemini 3.5 Flash # Step 4: Configure Review Policy Agent Manager → Review Policy: - Terminal Execution: Auto # runs npm/pip without asking - File Edits: Review # shows diff before applying - Browser: Ask # confirms before web actions # Step 5: Optional — Import VS Code settings Ctrl+Shift+P → "Antigravity: Import VS Code Settings"

ANTIGRAVITY CLI — TERMINAL-BASED AGENTS

# Install Antigravity CLI (replaces Gemini CLI — sunsets June 18, 2026) $ curl -fsSL https://antigravity.google/cli/install.sh | bash # Binary is named 'agy' (not 'antigravity') $ agy --version # verify installation $ agy auth login # sign in with Google account # Start an agent session in your project $ cd my-project $ agy # In the session — describe your task: > Build a REST API for user authentication using Express.js with JWT, bcrypt password hashing, and input validation. # Key advantage over IDE: async workflows # agy can orchestrate multiple sub-agents in background

ANTIGRAVITY 2.0 DESKTOP APP — PARALLEL AGENTS

# Download standalone desktop app (separate from IDE) Visit: antigravity.google → Download Desktop App # This is NOT the IDE — it's a separate agent control center # Key features unique to Desktop App 2.0: Parallel Agents: Run multiple agents simultaneously on different tasks Scheduled Tasks: Set agents to run on cron schedules automatically Projects: Organize agents by project with shared context Worktree Support:Each agent gets isolated Git worktree — no conflicts # Example: parallel agent workflow Agent 1: "Refactor the authentication module to use OAuth 2.0" Agent 2: "Write comprehensive tests for the payment service" Agent 3: "Update all API documentation for v2 endpoints" # All three run simultaneously — agents don't interfere with each other # Requires Google AI Pro ($20/mo) or Ultra ($100/mo)

02

🧠 Agent Skills — Antigravity's Secret Weapon

SKILL.md files that give agents project-specific knowledge on demand

+40 XP

What are Skills? Agent Skills are specialized packages of knowledge that sit dormant until needed. Instead of loading everything into context at once (causing tool bloat and higher costs), Skills use progressive disclosure — only loaded when a request matches the skill's description. This is identical to the SKILL.md system used in Claude Code and ASJ Agentra!

CREATING A PROJECT SKILL — .agents/skills/testing/SKILL.md

# Directory structure my-project/ ├── .agents/ │ └── skills/ │ ├── testing/ # Project-scoped skill │ │ └── SKILL.md │ └── database/ │ └── SKILL.md └── src/ # Example: .agents/skills/testing/SKILL.md --- name: testing-standards description: | Activate when user asks to write tests, add test coverage, create specs, or validate code quality. Use for Jest, Vitest, React Testing Library, or Playwright test creation tasks. --- # Testing Standards for This Project ## Test File Convention - Unit tests: src/__tests__/[component].test.ts - Integration tests: tests/integration/[feature].spec.ts - E2E tests: tests/e2e/[flow].spec.ts ## Coverage Requirements - Minimum 80% line coverage for new code - 100% coverage for utility functions in /src/utils/ ## Testing Rules - Never use real HTTP calls in unit tests — mock all fetch calls - Each test must have: Arrange, Act, Assert clearly separated - Test names format: "should [expected behavior] when [condition]"

Global vs Project Skills: Skills in ~/.gemini/config/skills/ are available across ALL your Antigravity projects. Skills in .agents/skills/ are project-specific only.

Claude Code

Anthropic's terminal-native agentic coding tool. The highest SWE-bench score (80.9%), 1M token context window, and $1B ARR in 6 months — the fastest product ramp in enterprise software history.

⚡ Why Claude Code Is Different

80.9%

SWE-bench Score

1M

Token Context

$1B

ARR in 6 Months

98.4%

Infrastructure Code

The architecture insight: Only 1.6% of Claude Code's codebase is AI decision logic. The other 98.4% is deterministic infrastructure — permission gates, context management, tool routing, and recovery logic. The agent loop is a simple while-loop; the real engineering complexity lives in the systems around it.

01

⚙️ Installation & Authentication

Get Claude Code running in your terminal in under 5 minutes

+25 XP

Claude Code — Terminal Setup

$ npm install -g @anthropic-ai/claude-code # macOS / Linux / Windows (WSL2 recommended) # Requires Node.js 18+ $ claude ✓ Claude Code v2.x.x → Sign in with your Anthropic account (claude.ai subscription required) → Claude Pro ($20/mo) includes Claude Code access $ cd my-project && claude ✓ Connected to project — reading codebase... ✓ Context loaded: 847 files, 124K tokens # Claude Code is now ready — type your task > Add rate limiting to the /api/auth endpoints using express-rate-limit

Key Surfaces

• Terminal CLI — main workhorse
• VS Code extension — sidebar integration
• JetBrains plugin — IDEA/PyCharm/WebStorm
• Desktop App — visual diff review, parallel sessions
• Web (claude.ai/code) — no local setup

Pricing (2026)

• Claude Pro ($20/mo) — Claude Code included
• Claude Max ($100/mo) — 5× usage
• API (usage-based) — enterprise teams
• Teleport — requires claude.ai subscription
• Included at Anthropic internally for all engineers

02

🧠 CLAUDE.md — Persistent Project Memory

Give Claude permanent context about your project across every session

+35 XP

What CLAUDE.md does: Claude Code reads CLAUDE.md automatically at the start of every session. It's your project's permanent memory — architecture rules, coding standards, team conventions, and forbidden patterns. Without it, Claude starts from zero every session. With it, Claude behaves like a senior engineer who has been on your team for months.

CLAUDE.md — PRODUCTION TEMPLATE

# CLAUDE.md — Project Memory File # Place at: project root (CLAUDE.md) ## PROJECT OVERVIEW Name: [Project Name] Description: [What it does in 2 sentences] Stack: [Framework + Language + Database + Key Libraries] Environment: Node 20, Python 3.12, PostgreSQL 16 ## ARCHITECTURE - Entry point: src/index.ts - API routes: src/routes/ (one file per resource) - Business logic: src/services/ (stateless functions only) - DB access: src/repositories/ (never query DB directly in routes) - Types: src/types/ (shared interfaces and enums) ## CODING STANDARDS - TypeScript strict mode — no 'any', no '!' non-null assertions - Async/await only — no callbacks or raw Promises - All errors must be caught and logged with context - Naming: camelCase functions, PascalCase classes, UPPER_SNAKE constants ## TESTING REQUIREMENTS - Write tests BEFORE implementing (TDD preferred) - Test file: [module].test.ts co-located with source - Mock all external services — never call real APIs in tests ## FORBIDDEN ACTIONS - NEVER install new npm packages — ask me first - NEVER modify .env or .env.example without discussing - NEVER use console.log in production code — use logger.ts - NEVER delete files — deprecate with comments and move to /archive ## COMMON COMMANDS npm run dev # Start development server npm test # Run test suite npm run lint # ESLint + Prettier check npm run build # Production build

03

🤖 Sub-Agents, Teleport & Power Features

Parallel agents, web-to-terminal handoff, and Slash commands

+40 XP

🔀 Sub-Agents (Parallel)

A lead agent spawns multiple sub-agents that work on different parts of a task simultaneously. Example: one sub-agent refactors the backend, another updates the API docs, another writes tests — all at once.

claude --parallel # or in session: > Spawn 3 agents: one for backend refactoring, one for test writing, one for API docs update

🌀 Teleport — Web ↔ Terminal

Start a long-running task on claude.ai or the iOS app, then pull it into your terminal with claude --teleport. The session, context, and progress all transfer seamlessly.

# On web: start a refactoring task # Pull into terminal when back at desk: $ claude --teleport ✓ Session restored from web

Essential Slash Commands

/help

List all available commands

/compact

Compress context to save tokens

/clear

Start fresh conversation

/desktop

Hand off session to Desktop App

/sandbox

Enable filesystem sandbox mode

/bug

Report an issue to Anthropic

Cursor — The IDE Leader

An AI-native VS Code fork that hit $1 billion in revenue in under 2 years. Composer multi-file editing, Tab prediction, and Agent Mode make it the daily driver for millions of developers.

🎯 Why Cursor Leads for Daily Development

Cursor is a VS Code fork where AI is first-class — not bolted on through an extension. Every feature was redesigned around AI assistance. The result: a dramatically better daily coding experience than standard VS Code + Copilot.

$1B ARR < 2 years IDE Market Leader $20/mo Pro

~65%

SWE-bench Est.

$20

Pro/Month

500K+

Active Devs

2

Years to $1B

01

⬇️ Setup, Composer & .cursorrules

Install Cursor and configure it for maximum AI productivity

+35 XP

CURSOR SETUP GUIDE

# Step 1: Download Cursor Visit: cursor.com → Download → Install (replaces VS Code) # All VS Code extensions work — import settings on first launch # Step 2: Sign up for Cursor Pro ($20/mo) # Hobby plan = 2,000 completions + 50 slow requests (limited) # Pro = unlimited completions + 225 fast requests/month # Step 3: Choose your model Settings → Models → Select: claude-sonnet-4-6 # Best for complex reasoning gpt-4o # Fast for quick edits # Step 4: Create .cursorrules at project root # This is Cursor's equivalent of CLAUDE.md # Step 5: Explore key features: Ctrl+L → Open Chat (ask questions about your code) Ctrl+K → Inline edit (edit selected code with AI) Ctrl+I → Open Composer (multi-file editing — most powerful feature) Tab → Accept inline completions (Cursor's autocomplete)

🔥 Composer — Cursor's Killer Feature

What Composer does: Composer (Ctrl+I) lets you describe a multi-file change in plain English. Cursor reads your entire codebase, plans the changes, shows you a diff across every affected file simultaneously, and applies everything with one click. It's why developers "fight procurement to get Cursor."

COMPOSER PROMPT EXAMPLES

# Example 1 — Feature addition Add a dark mode toggle to the app. It should remember the user's choice in localStorage. Update the ThemeProvider and add a toggle button to the Header component. Make sure all existing styles use CSS variables so they adapt automatically. # Example 2 — Refactor Refactor all API calls in the /services directory to use our new ApiClient class instead of direct fetch() calls. Handle errors consistently using the ApiError class. Don't change any component files — only service files. # Example 3 — Architecture Split the UserService class into three smaller services: AuthService (login, logout, tokens), ProfileService (get/update profile), and PermissionService (role checks). Update all imports across the codebase.

02

⚙️ Cursor Agent Mode + MCP Integration

Turn Cursor into an autonomous agent that runs and iterates independently

+25 XP

Agent Mode in Cursor: In Composer, switch from "Normal" to "Agent" mode. The agent will execute terminal commands, read error outputs, and iterate on its own solution until tests pass — without you intervening at each step.

CURSOR MCP CONFIGURATION — .cursor/mcp.json

// .cursor/mcp.json — connect Cursor to external tools { "mcpServers": { "filesystem": { "command": "npx", "args": ["@modelcontextprotocol/server-filesystem", "/path/to/project"] }, "github": { "command": "npx", "args": ["@modelcontextprotocol/server-github"], "env": { "GITHUB_TOKEN": "your_token" } }, "postgres": { "command": "npx", "args": ["@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"] } } }

⚔️ Agent Battle

Side-by-side comparison of every major AI coding tool — benchmarks, pricing, strengths, weaknesses, and the developer stack most professionals use in 2026.

⚡

Claude Code

Terminal-native autonomous agent. Project-level reasoning with 1M token context. Best raw benchmark scores. CLI-first philosophy.

TERMINAL AGENT

🎯

Cursor

AI-first VS Code fork. Composer for multi-file editing. Best IDE experience. Market leader. Daily driver for professional developers.

AI-NATIVE IDE

🐙

GitHub Copilot

Enterprise standard. 20M+ users, 42% market share, 90% Fortune 100 adoption. Multi-IDE. SOC 2 compliant. Microsoft ecosystem native.

ENTERPRISE DEFAULT

🌊

Windsurf → Devin Desktop

Acquired by OpenAI. Rebranded as Devin Desktop (June 2026). Cascade agentic feature is best-in-class for automated task chains. Uncertain roadmap.

AGENTIC IDE

🌌

Google Antigravity

Agent-first platform (not just IDE). Parallel sub-agents, scheduled tasks, enterprise Cloud integration. Gemini 3.5 Flash default. Free tier available.

AGENT PLATFORM

📊 Benchmark & Feature Comparison

Tool	SWE-bench	Context Window	Multi-file	Terminal	Sub-agents	Price/mo	Best For
⚡ Claude Code	80.9% 🏆	1M tokens	✓ Native	✓ Primary	✓ 1,000+	$20 (Pro)	Complex tasks, large codebases
🎯 Cursor	~65% est.	128K–200K	✓ Composer	✓ Agent	✗	$20 (Pro)	Daily development, IDE workflow
🐙 GitHub Copilot	~60% est.	128K	✓ Agent	✓ Limited	✗	$10 (Pro)	Enterprise, multi-IDE, GitHub teams
🌊 Windsurf/Devin	~62% est.	128K	✓ Cascade	✓ ACP	✓ Limited	$15 (Pro)	Automated task chains
🌌 Antigravity	N/A (Gemini)	1M+ tokens	✓ Native	✓ agy CLI	✓ Parallel	Free / $20	Parallel agents, Google ecosystem

🧭 Decision Framework — Which Tool Is Right For You?

Solo Dev / Startup?

→ Claude Code for complex reasoning tasks
→ Cursor for daily IDE workflow
→ Both for $40/mo total — highest ROI stack

Enterprise / GitHub Ecosystem?

→ GitHub Copilot — already IT-approved, SOC 2, Azure DevOps native
→ Add Claude Code for complex multi-file tasks

Google / Firebase Ecosystem?

→ Antigravity — free tier, native integration, parallel agents
→ Pair with Claude Code for hardest reasoning tasks

Windsurf / Devin Desktop?

→ Wait for OpenAI integration roadmap (Q2-Q3 2026)
→ Existing users: Cascade workflows still work, stay short-term

⚔️

BATTLE ANALYST

You've studied every tool's DNA, benchmarks, and use cases. Pick your stack wisely.

Prompting for Coding Agents

Prompting a coding agent is fundamentally different from prompting a chat AI. Agents execute — so your prompts must be clear about goals, constraints, scope, and verification criteria.

The Core Principle: A coding agent needs to know WHAT to build, HOW to verify it worked, WHAT boundaries not to cross, and WHAT the existing context is. Miss any of these and you get off-target, untestable, or destructive outputs.

📋 Task Prompts

🔄 Refactoring

🏛️ Architecture

🐛 Debugging

📄 AGENTS.md

Task Prompt Structure — The 5-Part Formula

Formula: GOAL + CONTEXT + CONSTRAINTS + VERIFICATION + SCOPE

❌ WEAK TASK PROMPT (What most people write)

Add user authentication to the app. # Agent doesn't know: what auth system, what routes to protect, # what the current state is, how to verify success, what to avoid

✅ STRONG TASK PROMPT (What gets results)

## GOAL Implement JWT-based user authentication for the Express.js API. ## CONTEXT - Stack: Express.js + TypeScript + PostgreSQL - User table already exists in /src/db/schema.ts (see the users table) - We use Winston for logging (import from /src/utils/logger.ts) - Password hashing: use bcrypt with 12 salt rounds ## WHAT TO BUILD POST /api/auth/register — validate input, hash password, create user POST /api/auth/login — validate credentials, return JWT (7d expiry) POST /api/auth/refresh — validate refresh token, return new access token GET /api/auth/me — protected route, return current user ## CONSTRAINTS - Do NOT modify any existing routes or middleware - Do NOT install new packages without listing them first - JWT secret must come from process.env.JWT_SECRET (already set in .env) - Store refresh tokens in the database (not in memory) ## VERIFICATION Write integration tests that: 1. Register a user successfully 2. Attempt duplicate registration (should fail) 3. Login with correct and incorrect credentials 4. Access protected route with valid/invalid/expired token

Refactoring Prompts — Scope Control is Everything

Warning: Refactoring prompts are the most dangerous. An agent without clear scope constraints will "helpfully" refactor far more than you asked — breaking things in the process. Always define exact scope.

REFACTORING PROMPT TEMPLATES

## Template 1: Targeted Refactor Refactor ONLY the UserService class in /src/services/UserService.ts. Current problem: It directly imports and calls the database — it should use the UserRepository instead (already exists in /src/repositories/). Changes allowed: - Replace all direct DB calls with UserRepository method calls - Update constructor to accept UserRepository as a dependency - Update types as needed Changes NOT allowed: - Don't modify any other files except UserService.ts - Don't change the public method signatures - Don't change how errors are thrown Verify: All existing tests in UserService.test.ts still pass. ## Template 2: Pattern Migration (large scope) Migrate all API route handlers in /src/routes/ from callbacks to async/await. SCOPE: Only files in /src/routes/ — nothing else. PATTERN: Replace (req, res, next) => { ... next(err) } with try/catch. VERIFY: Run npm test after each file — commit only if tests pass. ORDER: Do one file at a time, not all at once. Show me each diff. ## Template 3: Cleanup Remove all console.log statements from /src/services/ and replace them with the correct logger calls (logger.info, logger.error, logger.debug). Import logger from: import logger from '../utils/logger' Only change: the logging calls — nothing else in the logic.

Architecture Prompts — Explore Before You Build

Golden Rule: Never ask an agent to implement a new architecture in one shot. Use the Explore → Plan → Approve → Implement cycle. This prevents the agent from making large, destructive, hard-to-review changes.

ARCHITECTURE PROMPT CYCLE

## PHASE 1 — Explore (always start here) Before making any changes, explore the codebase and explain: 1. How the current authentication system works (files, flow) 2. What the main dependencies are between modules 3. Where the biggest risks are if we change the auth system 4. What approach you recommend and why DO NOT make any changes yet. Just analyze and explain. ## PHASE 2 — Plan (after you review Phase 1 output) Based on your analysis, create a detailed migration plan: - List every file that will change (with what changes) - List every file that will be created (with its purpose) - Estimate the risk level of each change (low/medium/high) - Propose an order of changes that minimizes breakage - Identify rollback points DO NOT implement anything yet. Just plan. ## PHASE 3 — Implement (after you approve the plan) Implement Phase 1 of the migration plan we approved: [paste specific part of plan here] After each significant change: run npm test and confirm tests pass. If tests fail: stop and tell me what failed before continuing. Commit with clear message after each successful phase.

Debugging Prompts — Give Context, Get Solutions

DEBUGGING PROMPT TEMPLATES

## Template 1: Specific Error I'm getting this error: [paste full error + stack trace] This happens when: [describe exact steps to reproduce] Expected: [what should happen] Actual: [what happens instead] Relevant files: [list files involved] Find the root cause and fix it. Before changing anything, explain what you think is causing this and why. ## Template 2: Performance Issue The /api/users endpoint takes 3–4 seconds to respond. Profile the request flow from route handler to database response. Look at: 1. N+1 query problems in the UserService 2. Missing database indexes (check schema.ts) 3. Unnecessary data fetching (are we loading relations we don't need?) Show me what you find before making any changes. ## Template 3: Flaky Tests These tests fail intermittently (not always): [list test names] They usually fail with: [error message] Investigate why they're flaky — common causes are: - Race conditions in async tests - Shared state between tests - Hard-coded timeouts - Missing test isolation Fix only the flakiness — don't change test logic or assertions.

Universal AGENTS.md Template — Works with All Tools

AGENTS.md / CLAUDE.md / .cursorrules — UNIVERSAL TEMPLATE

# AGENTS.md — Universal agent memory file # Compatible with: Claude Code (CLAUDE.md), Cursor (.cursorrules), # Antigravity (.agents/skills/), GitHub Copilot ## PROJECT IDENTITY Project: [Name] Purpose: [One-sentence description] Primary language: [Language + version] Framework: [Framework + version] Run: [How to start the dev server] Test: [How to run tests] Lint: [How to run linting] ## ARCHITECTURE RULES # Define your project's structural rules here: - [Layer A] only calls [Layer B] — never [Layer C] - All business logic lives in [folder] — never in [other folder] - External services accessed ONLY through [abstraction pattern] ## CODE STANDARDS # Your team's non-negotiables: - [Language-specific style rule] - [Error handling requirement] - [Testing requirement] - [Naming convention] ## FORBIDDEN ACTIONS - NEVER install packages without permission - NEVER modify [sensitive files/dirs] - NEVER delete files — archive instead - NEVER skip error handling - NEVER commit secrets or credentials ## VERIFICATION CHECKLIST Before marking any task complete: ☐ Does it follow the architecture rules? ☐ Are all new functions covered by tests? ☐ Does npm test / pytest pass? ☐ Did you check for console.log / debug statements? ☐ Are all imports clean (no unused imports)? ## COMMUNICATION STYLE When uncertain: STOP and ask before proceeding When tests fail: Report the failure — don't silently fix it When done: Summarize what changed, what was created, what to test

📝 Knowledge Quiz

10 questions covering vibe coding, coding agents, tool comparisons, and prompting patterns. Score 80%+ to unlock your certificate.

🏆 Your Certificate

Complete all missions and pass the quiz with 80%+ to unlock your sovereign certificate.

🔒

Certificate Locked

Complete the requirements below to unlock your Certificate of Completion for AI Coding Agents & Dev Environments.

🎯

Quiz Score: 80% or above required

⚡

XP Earned: Complete missions to accumulate XP

🛠️

Tools Mastered: VS Code, Antigravity, Claude Code, Cursor

AI CODING AGENTS& DEV ENVIRONMENTS

AI CODING AGENTS
& DEV ENVIRONMENTS