AI-Assisted Coding Tutorial – OpenClaw, GitHub Copilot, Claude Code, CodeRabbit, Gemini CLI

Summary of technological concepts, product features, and guidance

Why AI-assisted coding matters (and the “effectively” caveat)

• AI coding tools can significantly improve productivity while maintaining quality—but only if developers understand how to use them properly (when to apply them and when not to).
• Core course approach:
  • Learn the fundamentals (models/tokens/context/hallucinations)
  • Apply tools across the coding lifecycle: generation → review → refactor/testing

Fundamentals covered

• Tokens: AI input is split into token “word pieces,” affecting prompt cost and service limits.

• Context window: how much the model can “remember” at once. Examples:

  • GPT-4: ~128k tokens
  • Claude: up to ~200k tokens
  • Gemini: over ~1M tokens Practical implication: some tools can analyze more of your repo at once than others.

• Hallucinations: confidently wrong suggestions (fake APIs, nonexistent functions, deprecated references). Guidance: verify using docs/testing instead of blindly accepting code.

• Prompts: prompt clarity strongly affects output quality; later discussions mention “prompt engineering” and a formula for improved prompts.

When AI should be used vs. used cautiously

• AI is recommended for:
  • Boilerplate code (CRUD, getters/setters)
  • Learning new syntax/frameworks
  • Writing tests and documentation
  • Refactoring repetitive patterns
  • Fixing syntax errors
• AI should be used cautiously / with manual decision-making for:
  • System architecture design
  • Security-critical decisions
  • Complex business logic
  • Performance-critical optimizations

Framing: AI is a “fast knowledgeable junior developer,” but humans must decide the what/why and review the how.

---

GitHub Copilot tutorial (VS Code setup + workflows)

Setup and product notes

• Install GitHub Copilot Chat (not the deprecated older Copilot extension).
• Use VS Code integration:
  • Chat panel in the right sidebar
  • Toggle chat visibility
  • Uses inline ghost-text completions even when only the chat extension is installed.

Pricing guidance mentioned

• Free: ~2,000 completions + ~50 chat/agent requests per month.
• Pro for students/teachers/open-source: free with more advanced models and “unlimited completions.”

Demonstrated features and techniques

• Inline suggestions:
  • Accept by Enter (single-line) or Tab (larger block/function)
  • Shows alternatives when multiple completions exist (e.g., “1 out of 3” options)

• “Neighboring tabs” trick:

  • Copilot uses context not only from the active file, but also other open VS Code tabs.
  • Example: AI picks CSS class names and test IDs from related files (vs. generic names if those files aren’t open).

• Three chat interaction modes:

  1. Ask mode: explanations/learning; does not automatically change code.
  2. Edit mode: refactors via diff view; apply/discard line-by-line.
  3. Agent mode: autonomous multi-step actions across the repo (can create files, install packages, run tests/builds, execute terminal commands). Requires permission for “sensitive” file/command edits.

• Project customization via Copilot instructions

  • Uses a special instructions file (e.g., github/copilot instructions) to enforce project-specific rules (naming/style/auth/storage decisions).
  • Mentions /init to generate/update these instructions by scanning the repo.

• Participants/at-mentions and slash commands

  • Mentions act like “scoped assistants,” e.g.:
    • @workspace for whole-repo questions (e.g., where DB connection is defined)
    • @terminal, @vscode, @github for tool-specific actions
  • Slash commands demonstrated for:
    • documentation generation (/doc, /explain, /fix, /test, etc.)
    • initializing tests when none exist and selecting frameworks (mentions Mocha vs Jest-like options)

• Key takeaway: Copilot modes reduce hallucinations and improve code quality by controlling when code can be modified vs. only explained.

---

CodeRabbit tutorial (AI PR review + quality gate + CLI + agent loops)

What CodeRabbit is

• An AI-powered automated code review platform that triggers on PR creation.
• Features emphasized:
  • Automatic PR reviews immediately after PR creation
  • Security analysis to catch vulnerabilities
  • Code quality suggestions
  • PR chat to ask follow-up questions in natural language
  • Learning of codebase patterns over time
  • Integrations with GitHub/GitLab/Bitbucket/Azure DevOps

Review workflow described

• Create PR → CodeRabbit analyzes → returns:
  • summary of PR changes
  • issues with severity levels
  • suggested fixes (often “committable suggestions”)
• On new commits, it performs incremental reviews.

Demonstrated example: discount-code feature PR

• CodeRabbit flagged multiple issue types:
  • Security: hard-coded admin password/secrets
  • Authorization: admin endpoints unauthenticated (critical)
  • Input validation: don’t trust client-supplied totals; validate/clamp
  • Dead code / bugs
  • Minor/nitpicks
• It provided:
  • proposed code changes
  • clickable “commit suggestion” actions
  • inline PR comments and severity labeling
• It also showed how to ask CodeRabbit inside PR for targeted help (e.g., “secure these admin endpoints using middleware”).

CodeRabbit commands and customization

• PR-side commands include actions like:
  • pause, resume automatic reviews
  • review, full review
  • summary regeneration
  • resolve to mark comments resolved
  • doc string generation, sequence diagram generation
• Configuration via code rabbit.yaml:
  • Profile: chill (fewer nitpicks) vs assertive (more thorough, style suggestions)
  • Toggles for auto-review, drafts behavior, etc.
  • Profile recommendation: assertive for production repos; chill for personal/learning.

CLI workflows (review before committing)

• Use Homebrew + login; run CodeRabbit locally to review uncommitted or not-yet-fixed changes.
• CLI can apply suggestions or reject commits.
• Demonstrated generating prompts like “copy prompt to fix with AI” and then using another AI (e.g., Copilot) to implement fixes.
• Introduced a “feedback loop” pattern:
  • AI writes code → CodeRabbit reviews → AI fixes based on review
  • Optionally use “prompt only” mode for faster handoff to another agent.

Newer advanced features highlighted

• CodeRabbit Plan (pre-coding planning):
  • Comment @code rabbit AI plan on a GitHub issue
  • It analyzes the repo and outputs a detailed multi-task implementation plan plus agent prompts
  • Supports iteration and auto-planning when feature labels are added
• Premerge checks (quality gate):
  • Can block/flag PRs automatically and improve title/description summaries
• Multi-repo analysis:
  • Links dependent repos; detects breakages across frontend/backend or microservices (available on Pro plan)
• Benchmarked claim:
  • Mentions an independent “Code Review Bench” test (Martian) where CodeRabbit ranked #1 in F1 score across ~300k PRs

---

Command-line AI coding tools: Cloud Code, Claude CLI, Gemini CLI

Why CLI tools are used

• More autonomous, terminal-heavy workflow friendly, often larger context windows.
• Good fit for devops/system administration tasks.

Anthropic Claude Code / Cloud Code

• Install via npm; requires Claude Pro/API credits (no free tier).
• Interactive CLI session (claude command).
• Demonstrated:
  • codebase analysis → issues list → fix multiple items autonomously
  • “thinking modes” for depth (quick vs deep vs ultra)
  • capability to run terminal commands as part of the fix process
• Mentions project context files like claude.md to enforce conventions.

Google Gemini CLI

• Install via npm and authenticate (gemini-cli / gemini o login).
• Claimed advantages:
  • over 1M token context window
  • free tier (~1,000 messages/day)
  • multimodal (can interpret images)
• Demonstrated image→code workflow:
  • Provide an image (screenshot) and ask Gemini to update an SVG React/component-like output.
  • It can modify SVG to “add keys” after reviewing the visual.

---

OpenClaw (open-source personal AI assistant running locally)

Core concept

• Open-source assistant running on the user’s own computer.
• Functions like a “junior dev that never sleeps,” with:
  • always available messaging across chat apps (WhatsApp/Telegram/Discord)
  • persistent memory (24/7 context)
  • ability to take actions: run commands, manage files, deploy, send emails, run tests, open PRs, monitor CI/notifications

Setup and action capabilities

• Quick-start via website with a one-line command.
• Works on different machines (laptop, Mac mini/Studio, cloud VMs).
• Supports chat service connections and API keys.
• Demonstration:
  • Updated a live GitHub Pages website by cloning the repo and applying changes
  • Automation with cron jobs:
    • daily briefings, weekly scripts, outreach, checking sponsorships, etc.
  • Mentioned it can handle tasks via email even when APIs are limited by using a visual browser

Orchestration role

• Positioned as an orchestration layer that can coordinate other AI/code tools:
  • monitor PRs and respond to issues (CodeRabbit)
  • spawn/manage Cloud Code sessions
  • commit/push code via Copilot
• Differentiator: it can also build new “skills” (self-improving capability) by creating integrations and starting to use them once configured.

---

MCP (Model Context Protocol)

• Introduces MCP as a way to grant AI tools extra capabilities via external “apps/tools” (MCP servers).
• Without MCP, an AI tool is limited to what the user provides; with MCP it can access:
  • docs
  • databases
  • websites
  • test sites
• Example described:
  • config file (e.g., claude.cloudmcp.json) enabling:
    • web browsing automation (Puppeteer)
    • web search (DuckDuckGo)
    • file operations, GitHub repo actions, Postgres queries, etc.

---

Cross-tool workflow patterns + quality/security checklist

Recommended “two-agent” loop

• Use tests as concrete acceptance criteria:
  • Write tests with one tool
  • Generate implementation with another agent
  • Enforce quality via CodeRabbit review
  • Iterate until tests and review pass

Practical security guidance (strongly emphasized)

• AI-generated code requires human oversight.
• Quality checklist includes:
  • code runs
  • variables/functions defined
  • logic correctness
  • test edge cases
• Security essentials:
  • avoid hard-coded secrets/passwords/API keys (use environment variables)
  • avoid unsafe patterns like eval, SQL injection-prone string concatenation
  • ensure parameterized queries
  • verify authn/authz (especially admin endpoints)
  • don’t expose internals via error messages
  • keep dependencies updated

Prompting guidance

• Better prompts → better results.
• Include:
  • parameter types
  • expected output format
  • error handling requirements
  • style preferences
• “Tool to reach for” recap:
  • Copilot: real-time VS Code coding + learning APIs
  • CodeRabbit: PR security/quality gate + team consistency
  • Cloud Code/Gemini: refactoring, architectural discussions, autonomous dev sessions (Gemini also for multimodal)
  • OpenClaw: background automation + multi-tool orchestration

---

Main speakers / sources

• Bo KS (course instructor/primary speaker)
• CodeRabbit (product and CLI/tool referenced; no individual author quoted)
• GitHub Copilot / GitHub
• Anthropic (Claude Code / Claude CLI)
• Google (Gemini CLI)
• OpenClaw (open-source assistant; referenced via OpenClaw.ai / documentation)
• Martian (independent benchmark organization mentioned via “Code Review Bench”)