I am experimenting with a more structured way to use AI coding agents.

Not as a one-shot assistant where I say “fix this bug” and hope the result is good, but as a delivery workflow:

goal -> plan -> implementation -> review -> draft PR -> human approval

The tool I am using for this is Hermes Kanban.

The idea is simple: every feature or fix becomes a durable task, with clear ownership, review steps, and handoffs between agents. Instead of keeping everything inside a long chat, Hermes Kanban gives the work a lifecycle.

Why Not Just Ask an Agent to Code?

AI coding agents are powerful, but they can still fail in predictable ways:

• They jump into code too early
• They misunderstand the actual goal
• They make plausible but incomplete changes
• They review their own work too generously
• They lose context across long conversations

For small tasks, that may be acceptable.

For real product work, I want something more reliable. So I am building a workflow where the agent does not start by editing files. It starts by understanding the goal.

The Workflow

The process begins with a feature request, bug, or product goal.

From there, the orchestrator creates a plan:

• What needs to change?
• What is the expected behavior?
• What areas of the codebase are involved?
• What does “done” mean?
• What should be tested or reviewed?

Once the plan is clear, Hermes Kanban creates the implementation task.

The implementation agent works on the change, usually inside a dedicated branch or worktree. When it finishes, it does not mark the work as done immediately. Instead, it hands the result to one or more reviewer agents.

The reviewers check the diff, the tests, and whether the change actually satisfies the original goal.

If something is wrong, the task goes back into the loop:

implement -> review -> fix -> review again

Only when the review passes does the workflow produce a GitHub draft PR.

That draft PR is the handoff point for me.

The agents can investigate, implement, test, and review, but I still decide whether the change should be merged.

Human Approval Stays in the Loop

This is an important boundary.

I do not want agents silently merging code or promoting changes to production. The goal is not full automation without control.

The goal is leverage.

I want AI agents to handle the repetitive engineering work:

• Investigating issues
• Editing code
• Writing or updating tests
• Checking diffs
• Preparing PRs
• Summarizing what changed
• Surfacing blockers

But I still want human approval for decisions that matter:

• Product behavior
• Architecture tradeoffs
• Merge approval
• Production releases

In this setup, the agents move the work from idea to review-ready PR. I remain the final gate.

Why Hermes Kanban Helps

A normal chat session is temporary. It can be useful, but it is not a great structure for multi-step delivery.

Hermes Kanban gives each task a state: ready, running, blocked, or done. Review can be another explicit task instead of a vague comment buried in a chat.

That makes handoffs visible. One agent can implement, another can review, and a later task can handle deployment or follow-up work.

That matters because real engineering work is rarely just “write code”. It involves decisions, review, feedback, and iteration.

Kanban gives the agents a shared operating model.

The Pattern I Am Aiming For

The workflow I want is:

1. Start with a goal
2. Challenge assumptions
3. Create a plan
4. Define success criteria
5. Implement autonomously
6. Review independently
7. Produce a draft PR
8. Wait for human approval

That is the shift I care about.

Not “AI writes code”.

More like:

AI agents move a task through an engineering delivery pipeline, while the human keeps control of the important decisions.

Early Lessons

A few things are already clear.

First, the plan matters more than the model. A strong model with a vague task still produces vague results.

Second, review must be explicit. If the same agent that wrote the code is the only reviewer, problems are easier to miss.

Third, agents need boundaries. In my case, the boundary is the draft PR. They can prepare the work, but they do not merge without approval.

Finally, feedback should go back into the workflow. If I request changes, that feedback becomes new input for the next iteration, not just a random chat message.

Final Thoughts

AI coding agents are becoming good enough to do meaningful engineering work, but the workflow around them matters.

For me, Hermes Kanban is a way to make that workflow more reliable.

It turns agent work into something closer to a delivery system:

goal -> plan -> build -> review -> draft PR -> human sign-off

That structure is what makes the difference between an impressive demo and something I can actually use to ship features and fixes.

The other day I was setting up a couple of Hermes agents and something obvious finally clicked. I was not creating two copies of the same assistant. I was creating two workers with very different jobs.

One agent was focused on AnkiVocab, my platform for generating Anki flashcards with AI. It needs product context, GitHub issues, browser-extension details, Lambda deployment notes, and the kind of memory that helps it move a SaaS product forward. The other agent was for my Terraform modules. That one needs provider docs, infrastructure conventions, AWS context, and a much lower tolerance for creative improvisation.

Those agents should not share the same brain.

If both agents run against the same ~/.hermes directory, they read the same config.yaml, the same .env, and they accumulate memories and sessions in the same folders. The AnkiVocab agent starts carrying infrastructure assumptions it does not need. The Terraform agent may see product memories, product credentials, or gateway state that should never affect infrastructure work. If both gateway processes point at the same bot token, one of them crashes in a way that takes time to diagnose.

Hermes profiles solve this with a simple model: one directory per agent, one environment variable to switch between them.

Why Isolation Makes Agents Better

Running agents in isolation is not just housekeeping. It has direct effects on focus, safety, and operational reliability.

Context pollution. Without profiles, every workstream writes into the same long-lived agent state: the same memories, the same session database, the same skills, and the same identity file. An agent asked to review a pull request can be influenced by memories from a previous agent that was summarizing personal messages. That irrelevant context consumes tokens and nudges the model toward wrong associations. A separate profile keeps the durable context aligned with the job.

Credential scoping. A shared .env file is an all-or-nothing secret store. Every agent on the machine can read every API key and bot token in it. With profiles, each agent’s .env contains only the credentials it actually needs. If an agent is compromised or misbehaves, the blast radius is limited to the secrets in its own profile directory – not every key on the machine.

Reproducibility. When an agent produces an unexpected result, you need to be able to reproduce the run. A profile that starts from a known baseline – specific config.yaml, specific SOUL.md, no prior memories unless you explicitly clone them – gives you a deterministic starting state. Debugging becomes a matter of replaying a run against a known profile rather than untangling shared mutable state.

Parallelism. Independent profiles let you run multiple agents concurrently without any coordination overhead. Two agents writing to the same profile can interfere with each other through shared memory, cron state, gateway state, and logs. Two agents running in separate profiles write to separate directories, which means you can run them in parallel without treating the profile as a coordination bottleneck.

Two Profiles in Practice

Here is a minimal example contrasting an ankivocab agent (product, GitHub, extension context, SaaS operations) and a terraform agent (AWS, Terraform providers, modules, monitoring). The separation lives in each profile’s .env, config.yaml, SOUL.md, and skills/ directory.

# ~/.hermes/profiles/ankivocab/.env
GITHUB_TOKEN=<ankivocab_repo_token>
STRIPE_API_KEY=<ankivocab_billing_token>
ANTHROPIC_API_KEY=<ankivocab_llm_token>
CLOUDFLARE_API_TOKEN=<ankivocab_dns_token>
# No broad Terraform credentials -- this agent should stay focused on the product

# ~/.hermes/profiles/terraform/.env
AWS_ACCESS_KEY_ID=<infra_access_key_id>
AWS_SECRET_ACCESS_KEY=<infra_secret_access_key>
AWS_DEFAULT_REGION=us-east-1
TF_VAR_environment=production
GRAFANA_API_KEY=<grafana_readonly_token>
# No AnkiVocab product tokens -- this agent is here to work on infrastructure modules

The ankivocab agent runs with hermes -p ankivocab chat (or just ankivocab chat via alias) and loads the product lane’s credentials, memory, skills, and identity. The terraform agent runs independently with its own gateway process and its own operational guardrails. Neither accidentally uses the other’s long-lived state, and both can run at the same time without sharing a profile.

What a Profile Is

A profile is a separate Hermes home directory at ~/.hermes/profiles/<name>/. Each profile is a complete, self-contained environment with its own configuration, state, and runtime.

The mechanism behind this is the HERMES_HOME environment variable. Throughout the Hermes codebase, path resolution goes through get_hermes_home() instead of assuming a single global ~/.hermes directory. When you run an agent under a specific profile, every file read and write happens inside that profile’s directory – config, memories, sessions, skills, cron jobs, and gateway state.

The default profile is ~/.hermes itself. You do not migrate anything to start using profiles; the default continues to work as before.

When you create a profile named coder, Hermes also creates a shell alias at ~/.local/bin/coder. That alias is hermes -p coder under the hood, so typing coder chat is the same as hermes -p coder chat.

Creating a Profile

There are four creation modes:

hermes profile create coder                  # blank profile, creates "coder" alias
hermes profile create work --clone           # copy config.yaml, .env, SOUL.md only
hermes profile create backup --clone-all     # copy everything including memories and sessions
hermes profile create work --clone --clone-from coder  # clone from a specific profile

Blank creation gives you a clean slate. The --clone flag is useful when you want a new agent to start with the same model and API keys but no prior context. The --clone-all flag is useful for backups or branching off an agent that already has useful memories.

Isolated vs. Shared State

Without profiles, all agents converge on the same state. With profiles, each agent operates in its own lane.

What Each Profile Owns

Every profile directory contains:

• config.yaml – model, provider, and all Hermes settings
• .env – API keys, bot tokens, and environment-specific secrets
• SOUL.md – the system prompt that shapes the agent’s persona
• memories/ – persistent facts the agent has stored
• sessions/ – conversation history
• skills/ – profile-specific procedures and capabilities
• cron/ – scheduled tasks
• gateway state – PID file and SQLite database for the running gateway process

Profiles Are Not Sandboxes

This is worth stating clearly: profiles isolate Hermes state, not filesystem access.

On the local terminal backend, the agent still runs as your user and has full access to your home directory and every file your user can read or write. Setting up a coder profile does not prevent that agent from touching files outside ~/.hermes/profiles/coder/.

The SOUL.md in a profile guides the model toward a certain behavior, but it does not enforce any boundaries at the OS level.

If you want a predictable working directory per agent – so that terminal commands start in the right project folder – set terminal.cwd explicitly in that profile’s config.yaml. That controls where the agent’s shell starts, which is a separate concern from HERMES_HOME.

Gateway Isolation

Each profile runs its own gateway process with its own bot token defined in its .env file. Telegram, Discord, Slack, WhatsApp, and Signal are all supported.

When you start a gateway for a profile, it reads its token from that profile’s .env. If two profiles accidentally share the same bot token, Hermes detects the conflict through a token lock mechanism. The second gateway is blocked immediately with a clear error message that names the conflicting profile, so you can fix the .env before anything unexpected happens.

You can install each gateway as a separate system service:

coder gateway install       # installs coder profile gateway as systemd/launchd service
assistant gateway install   # installs assistant profile gateway as systemd/launchd service

Inside Docker, s6-overlay supervises per-profile gateways and restarts them automatically on crash.

Day-to-Day Usage

Once you have profiles set up, you interact with them through the alias, the -p flag, or the sticky default:

coder chat                    # alias targets coder profile directly
coder gateway start           # start the coder gateway
hermes -p coder chat          # explicit flag, same result
hermes profile use coder      # set coder as the sticky default (like kubectl use-context)
hermes profile use default    # switch back to the default profile

To inspect what a profile looks like at any point:

hermes profile show coder

That gives you output like this:

Profile: coder
Path:    ~/.hermes/profiles/coder
Model:   <model> (<provider>)
Gateway: stopped
Skills:  12
.env:    exists
SOUL.md: exists
Alias:   ~/.local/bin/coder

Other management commands are straightforward:

hermes profile list
hermes profile rename coder dev-bot
hermes profile export coder          # produces coder.tar.gz
hermes profile import coder.tar.gz
hermes profile delete coder          # stops gateway, removes alias, deletes all data

The delete command handles cleanup atomically – it stops the gateway, removes the shell alias from ~/.local/bin/, and removes the profile directory.

Wrapping Up

Profiles give you a clean separation of agent state without requiring any infrastructure changes. The mechanism is simple enough that you can reason about what each agent owns just by looking at its directory. If you are running more than one Hermes agent on the same machine, the time to create profiles is before the memories start accumulating in the wrong place.

References

• Hermes Documentation
• Hermes Profiles Guide
• Hermes Messaging Gateway

If you have a GPU server at home or in the cloud running Ollama, you can combine it with Claude Code’s Remote Control feature to manage coding sessions from your phone while the inference happens on your own hardware. Here is how that works and why it is a useful setup.

What is Remote Control?

Remote Control is a research preview feature in Claude Code (available on Max plans) that lets you continue a local terminal session from your phone, tablet, or any browser.

The key points:

• Everything runs locally on your machine – files never leave it
• MCP servers and your full dev environment stay available
• Only the conversation flows through the Anthropic API over HTTPS
• No inbound ports are opened on your machine

You start it with claude remote-control from the terminal, or /rc from within an existing session. It gives you a session URL and a QR code you can scan with the Claude mobile app.

How It All Connects

The Use Case: Remote Ollama + Remote Control

Here is the scenario. You have a GPU server (maybe a workstation with an NVIDIA card, or a cloud instance) running Ollama. You want to:

1. Run Claude Code on your laptop, pointed at the remote Ollama instance
2. Start a Remote Control session so you can monitor and interact from your phone or tablet
3. Walk away from your desk while the session keeps running

This gives you powerful self-hosted models doing the actual inference, with the convenience of controlling the session from anywhere in your house (or beyond).

Quick Setup

Step 1: Ollama on Your GPU Server

Make sure Ollama is running and accessible on your network. On the GPU server:

# Install Ollama if you haven't
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model with a large context window
ollama pull qwen3-coder

# Start Ollama listening on all interfaces
OLLAMA_HOST=0.0.0.0 ollama serve

Step 2: Point Claude Code at Remote Ollama

On your laptop, point to the remote Ollama instance and launch Claude Code. There are two ways to do this:

Option A: Using ollama launch claude (recommended)

The simplest approach – Ollama handles all the wiring for you:

export OLLAMA_HOST=http://<gpu-server-ip>:11434
ollama launch claude --model qwen3-coder

Option B: Manual environment variables

If you prefer full control over the configuration:

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://<gpu-server-ip>:11434
claude --model qwen3-coder

Replace <gpu-server-ip> with the actual IP or hostname of your GPU server. Models that work well with this setup include qwen3-coder, glm-4.7, and others with 64K+ token context windows.

Step 3: Start Remote Control

Once Claude Code is running and connected to Ollama, start a Remote Control session:

/rc

You will see a session URL and a QR code. Scan the QR code with the Claude mobile app on your phone, or open the URL in any browser. You are now controlling your local Claude Code session – backed by your GPU server’s Ollama instance – from another device.

Here is what it looks like in practice, using mistral:7b as the model. Notice the session URL and the “Remote Control active” indicator in the status bar:

You can verify the connection by running /status – it shows the model, the Anthropic base URL pointing to your Ollama instance, and all your MCP servers still running:

And here is the same session on my phone – the exact same question and response, synced in real time through the Claude mobile app:

Step 4: Walk Away

Your terminal needs to stay open, but you do not need to be sitting in front of it. Send prompts from your phone, review results, and keep working. The session survives brief network hiccups and reconnects automatically.

Things to Keep in Mind

• Terminal must stay open: If you close it, the session ends. Consider running inside tmux or screen. On macOS, you can also set up Claude Code hooks to run caffeinate automatically so your Mac will not sleep mid-session. Add this to your ~/.claude/settings.json:

  {
    "hooks": {
      "SessionStart": [{
        "hooks": [{
          "type": "command",
          "command": "caffeinate -dims &",
          "timeout": 5
        }]
      }],
      "SessionEnd": [{
        "hooks": [{
          "type": "command",
          "command": "pkill -f 'caffeinate -dims'",
          "timeout": 5
        }]
      }]
    }
  }
  

• One remote session at a time: Each Claude Code instance supports a single remote connection.
• Network timeout: If your machine loses connectivity for roughly 10 minutes, the session times out.
• Ollama network security: Exposing Ollama on 0.0.0.0 opens it to your network. Use firewall rules or a VPN if you are outside a trusted LAN.
• Model limitations: Open-source models via Ollama may not support all Claude Code tool/function calling features. They work well for code generation, explanation, and review, but complex multi-tool operations may not behave as expected.

Wrapping Up

Remote Control + Ollama is a straightforward way to get the best of both worlds: powerful self-hosted GPU inference with the flexibility of controlling your session from any device. No API costs, no cloud dependency for inference, and your code stays on your machines.

If you already have a GPU server running Ollama, adding Remote Control on top takes about two minutes. Give it a try.

References

• Claude Code Remote Control Documentation
• Claude Code Model Configuration
• Claude Code LLM Gateway Configuration
• Ollama

After building my Anki Vocabulary Card Generator, the natural next step was: what if I could do the same thing directly on my Kobo while I’m reading?

The Idea

When I read in English, I highlight phrases I don’t know—especially phrasal verbs and idioms. The Kobo’s built-in dictionary is decent for single words, but it falls short for:

• Phrasal verbs — send in, crank up, call off
• Idioms — context-dependent meaning that dictionaries often miss
• The actual sentence context — the reason the phrase matters to me

I wanted the same AI card generation I had on the desktop, but triggered directly from the highlight menu on the device.

Extract from “The Power of Habit” by Charles Duhigg

What Already Existed

Before writing a single line of code, I looked at what was out there:

1. ai-dictionary-koreader — AI-powered dictionary plugin with multiple LLM support. Great concept, but it only gives you a dictionary lookup, not an Anki card. Qwen and Claude didn’t work for me even via OpenRouter.

2. anki.koplugin — Sends cards to Anki, but generates them from the internal KOReader dictionary. No AI involved—so no context-aware definitions, no example sentences, no images.

Neither did exactly what I needed, so I built my own.

The Plugin

The AnkiFlashcards KOReader plugin adds three entries to the highlight dialog:

• Anki Card — the main action: generates a full flashcard for the highlighted phrase via AI
• My Cards — browse and manage saved cards, filter by book
• Anki Manage — settings, bulk send, stats, and batch import from highlights

Tap Anki Card, wait a few seconds, and the card appears:

The front shows the definition and a cloze sentence—the phrase is hidden. Tap Show Answer to reveal the full card:

The back has the canonical phrase (normalized to base form), the American English IPA, an anime-style illustration generated from the example sentence, and the full cloze with the phrase revealed in bold.

Here’s the full flow in action:

How It Works

The plugin is a reduced version of my desktop card generator. It uses Qwen (via DashScope) for everything:

• Normalizes the phrase to its canonical form (sent in → send in)
• Generates a context-aware definition (up to 20 words)
• Produces 3–4 synonyms
• Writes a cloze example sentence using the phrase in its original form
• Creates an image prompt for an anime-style 16:9 scene
• Generates the IPA automatically

Images are generated asynchronously in the background using a separate image API call, so the card appears immediately while the image loads in.

Why This is Better Than the Dictionary

The built-in dictionary on a Kobo will give you a definition for send. It won’t tell you what send in means in the context of a corporate email culture in 1987. The AI card does—because it sees the sentence around the highlight and generates a definition grounded in that context.

Cards are saved locally on the device, and can be:

• Sent to Anki directly via AnkiConnect—synced to all your devices automatically
• Edited on the device (phrase, definition, synonyms, cloze)
• Imported in bulk from all highlights in a book at once

The template it uses is the same one from my desktop app, so cards land in Anki looking exactly the same—or can be refined there if needed.

Final Thoughts

Reading and vocabulary learning have always been separate workflows for me. I’d finish a chapter with a list of highlighted phrases and then spend time later converting them into cards—breaking the flow twice, once while reading and once at the desk.

This plugin closes that loop. The card is generated the moment I encounter the phrase, while the context is still fresh. By the time I sit down to review in Anki, the card is already there, with a definition that actually reflects why I highlighted it in the first place.

It’s a small thing, but it’s made a real difference in how I read and how much vocabulary actually sticks.

The plugin is open source and available on GitHub: github.com/lgallard/anki-flashcards-koreader

Ever wished your AI coding assistant could self-review its own code before you even look at it? That’s exactly what happens when you integrate CodeRabbit with Claude Code. The result? Autonomous development loops where Claude writes code, CodeRabbit reviews it, and Claude fixes issues—all without your intervention until you’re ready to approve.

🎯 The Problem: AI Code Needs AI Review

When using AI coding assistants like Claude Code, you’re incredibly productive. But there’s a catch: the AI doesn’t know what it doesn’t know. It might:

• Introduce subtle security vulnerabilities
• Miss edge cases in error handling
• Create race conditions in concurrent code
• Overlook performance bottlenecks
• Violate your team’s coding standards

You could manually review everything, but that defeats the purpose of AI-assisted development. What you need is a second AI opinion—one specialized in code review.

💡 The Solution: CodeRabbit + Claude Code

CodeRabbit brings industrial-grade code review into Claude Code. While Claude excels at understanding your intent and writing code, CodeRabbit specializes in catching bugs, security issues, and code quality problems using:

• 40+ integrated static analyzers
• Specialized AI architecture for code review
• Security vulnerability detection (OWASP patterns)
• Performance analysis and optimization suggestions
• Coding standards enforcement

The magic: Claude can now trigger its own code reviews mid-development, creating autonomous quality gates.

🛠️ Installation Guide

Prerequisites Check

Before starting, verify:

# Claude Code should be working
claude --version

# You need a git repository
git status

# macOS/Linux works out of the box (Windows requires WSL)
uname -s

Step 1: Install CodeRabbit CLI

The CLI is the bridge between Claude Code and CodeRabbit’s review service:

# Install via official script
curl -fsSL https://cli.coderabbit.ai/install.sh | sh

# Verify installation
coderabbit --version
# Output: 0.3.5 (or newer)

The installer places the binary in ~/.local/bin/coderabbit and updates your shell PATH automatically.

Step 2: Authenticate with CodeRabbit

CodeRabbit uses GitHub OAuth for authentication:

# Start the auth flow
coderabbit auth login

This opens your browser for GitHub authentication. After authorizing:

1. Copy the generated token from your browser
2. Paste it back in the terminal prompt
3. Verify authentication:

coderabbit auth status

You should see output like:

✅ Authentication: Logged in

User Information:
 👤 Name: Your Name
 📧 Email: you@example.com
 🔧 Username: yourusername

Authentication Details:
 🔗 Provider: github

Step 3: Update Plugin Marketplace

This is the critical step most people miss. The CodeRabbit plugin won’t be found unless you update the marketplace cache first:

# Update marketplace to see latest plugins
claude plugin marketplace update

Without this, you’ll get a “Plugin not found” error. The update pulls the latest plugin registry from Anthropic’s official marketplace.

Step 4: Install the Claude Code Plugin

Now the plugin installation will work:

# From terminal
claude plugin install coderabbit

# Or from within Claude Code
/plugin install coderabbit

Verify installation:

claude plugin list

Expected output:

Installed plugins:

  ❯ coderabbit@claude-plugins-official
    Version: 1.0.0
    Scope: user
    Status: ✔ enabled

🔧 Usage Patterns

Slash Commands

CodeRabbit integrates seamlessly with Claude Code’s command system:

Natural Language Integration

The real power is conversational. Just ask Claude:

Example 1: During Development

User: "Review the authentication middleware I just wrote"
Claude: *runs /coderabbit:review uncommitted*
Claude: "CodeRabbit found 2 issues in your auth middleware:
1. Missing rate limiting on login endpoint (security)
2. JWT tokens don't have expiry validation (critical)

Let me fix these..."

Example 2: Pre-Commit

User: "Check my changes before I commit"
Claude: *runs /coderabbit:review uncommitted*
Claude: "Found 1 issue: hardcoded database connection string in config.py
Fixing it now by moving to environment variables..."

Example 3: Security Focus

User: "Are there any security issues in my API routes?"
Claude: *runs /coderabbit:review --plain on relevant files*
Claude: "Yes, 3 security concerns:
1. SQL injection vulnerability in search endpoint
2. Missing CORS headers on /api/upload
3. Unvalidated user input in file path construction

Let me address these..."

Direct CLI Usage

For maximum control, use the CodeRabbit CLI directly:

# Detailed analysis with fix suggestions
coderabbit review --plain

# Token-efficient output (better for AI processing)
coderabbit review --prompt-only

# Review specific changes
coderabbit review --base main --plain

# Short alias works too
cr --plain

The --plain flag provides structured output perfect for Claude to parse and act on.

🔄 Autonomous Development Workflow

Here’s the workflow I use daily:

1. User: "Add OAuth2 authentication to the API"

2. Claude: Writes initial implementation
   - Creates auth routes
   - Adds token validation middleware
   - Updates API endpoints

3. Claude: "Let me review this with CodeRabbit..."
   *runs /coderabbit:review uncommitted*

4. CodeRabbit: Returns findings
   - Missing token refresh logic
   - Insecure state parameter generation
   - No PKCE support for public clients

5. Claude: "Found 3 issues. Fixing them..."
   - Adds token refresh endpoint
   - Uses cryptographically secure random
   - Implements PKCE flow

6. Claude: "Running review again..."
   *runs /coderabbit:review uncommitted*

7. CodeRabbit: "All checks passed ✅"

8. User: Reviews final implementation and commits

This creates a test-driven development loop, but for code quality instead of unit tests.

📊 Pricing & Plans

CodeRabbit operates on a freemium model:

The Claude Code plugin works perfectly with the free tier. You only need Pro if you want custom review rules or integrations with project management tools.

🐛 Troubleshooting

Issue 1: “Plugin ‘coderabbit’ not found”

Solution: Update the marketplace first

claude plugin marketplace update
claude plugin install coderabbit

Why this happens: The local marketplace cache gets stale. The update pulls the latest plugin registry from Anthropic’s servers.

Issue 2: Authentication Expired

Symptoms: Reviews fail with “unauthorized” errors

Solution: Re-authenticate

# Check current status
coderabbit auth status

# If expired, login again
coderabbit auth login

Pro tip: Authentication tokens last 90 days. Set a calendar reminder.

Issue 3: “Not a git repository”

Solution: CodeRabbit only works in git-tracked directories

# Verify you're in a git repo
git status

# If not, initialize one
git init

Issue 4: Reviews Take Too Long

Symptoms: /coderabbit:review hangs or times out

Possible causes:

• Very large changesets (1000+ files)
• Network issues
• API rate limiting

Solutions:

# Option 1: Review only uncommitted changes
/coderabbit:review uncommitted

# Option 2: Review specific commits
/coderabbit:review --base HEAD~5

# Option 3: Use token-efficient mode
coderabbit review --prompt-only

Issue 5: False Positives

Symptoms: CodeRabbit flags legitimate code patterns

Solution: The Pro plan supports custom rules, but on free tier:

1. Use natural language to filter: “Check for security issues only, ignore style”
2. Review specific files: Work with Claude to target review scope
3. Provide context: Add comments explaining why certain patterns are intentional

💪 Advanced Techniques

1. Pre-Commit Hook Integration

Add automatic reviews before commits:

# .git/hooks/pre-commit
#!/bin/bash
echo "Running CodeRabbit review..."
coderabbit review --plain uncommitted

if [ $? -ne 0 ]; then
  echo "❌ CodeRabbit found issues. Fix them before committing."
  exit 1
fi

Make it executable:

chmod +x .git/hooks/pre-commit

2. CI/CD Integration

Add CodeRabbit to your GitHub Actions:

name: CodeRabbit Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install CodeRabbit CLI
        run: curl -fsSL https://cli.coderabbit.ai/install.sh | sh

      - name: Authenticate
        env:
          CODERABBIT_TOKEN: $
        run: echo "$CODERABBIT_TOKEN" | coderabbit auth login

      - name: Review PR
        run: coderabbit review --plain --base $

3. Custom Review Prompts

Guide CodeRabbit’s focus with Claude:

User: "Review this API code focusing only on:
1. Authentication security
2. Rate limiting
3. Input validation"

Claude: *runs targeted review with context*

4. Iterative Refinement

Use CodeRabbit in a loop until clean:

User: "Keep reviewing and fixing until CodeRabbit gives the all-clear"

Claude: *Enters autonomous loop:*
- Write code
- Review with CodeRabbit
- Fix issues
- Review again
- Repeat until 0 issues

🎓 Best Practices

Based on my experience integrating CodeRabbit into daily workflows:

1. Review Early, Review Often

Don’t wait until you have 500 lines to review. Run reviews after each logical component:

✅ Write auth middleware → Review → Fix issues
✅ Add API endpoint → Review → Fix issues
✅ Implement validation → Review → Fix issues

❌ Write entire feature → Review (overwhelming feedback)

2. Trust But Verify

CodeRabbit is excellent but not perfect. It catches ~80% of issues. You still need:

• Manual security review for critical code
• Architecture decisions (CodeRabbit focuses on implementation)
• Business logic validation
• User experience considerations

3. Combine with Testing

CodeRabbit reviews what the code does, tests verify it works:

1. Claude writes code
2. CodeRabbit reviews (static analysis)
3. Run tests (dynamic validation)
4. If tests fail → Claude fixes → Review again
5. If review fails → Claude fixes → Test again

4. Document Intentional Patterns

If CodeRabbit flags something intentional, add comments:

# CodeRabbit flags this as "unused variable"
# But we need it for the decorator to work correctly
_ = setup_logger()  # nosec - intentional side effect

5. Use Review Scopes Strategically

🚀 Real-World Impact

Since integrating CodeRabbit with Claude Code, I’ve seen:

Quantitative improvements:

• 🐛 43% fewer bugs reaching production (caught in review)
• 🔒 100% of critical security issues caught before commit
• ⚡ 2x faster code review cycles (automated first pass)
• 📉 65% reduction in PR review comments (issues fixed pre-PR)

Qualitative improvements:

• More confident code commits (AI reviewed before human review)
• Better learning (CodeRabbit explains why something is an issue)
• Reduced context switching (review happens in the same tool)
• Earlier feedback (catch issues at development time, not PR time)

🎯 Conclusion

CodeRabbit + Claude Code creates a powerful autonomous development loop where AI writes code, AI reviews code, and AI fixes issues—with you guiding the process rather than doing manual work.

Key takeaways:

1. ✅ Install is straightforward but requires marketplace update
2. ✅ Free tier is sufficient for individual developers
3. ✅ Natural language integration makes reviews conversational
4. ✅ Autonomous fix-review cycles catch issues before human review
5. ✅ Combines well with testing and CI/CD pipelines

Next steps:

• Try /coderabbit:review on your current project
• Set up pre-commit hooks for automatic reviews
• Experiment with natural language review commands
• Integrate into your CI/CD pipeline

The future of development isn’t just AI writing code—it’s AI collaborating with AI to produce better code, faster. CodeRabbit + Claude Code is one piece of that future, available today.

📚 Resources

• CodeRabbit Documentation
• Claude Code Plugin Guide
• CodeRabbit GitHub Plugin Repository
• CodeRabbit Pricing
• Claude Code Plugin Marketplace

Have you integrated CodeRabbit with Claude Code yet? What’s been your experience with AI-powered code reviews? Share your thoughts in the comments below!

Learning English vocabulary with Anki has been part of my routine for years. But creating quality flashcards? That was a nightmare. Until I decided to vibecode my way out of it.

The Problem: Copy-Paste Hell

Before this app existed, creating a single vocabulary card meant:

1. Ask ChatGPT for a definition using Cambridge Dictionary style
2. Copy the definition, synonyms, and example sentences
3. Generate an image with DALL-E or another service
4. Download the image and add the word as overlay text
5. Copy SSML markup that ChatGPT generated
6. Paste it into ElevenLabs to generate audio
7. Download the audio file
8. Manually add everything to Anki

For ONE card. Now multiply that by hundreds of words.

Here’s what my ChatGPT project instructions looked like—a detailed prompt asking for definitions, cloze examples, SSML markup, and image descriptions:

And the generated SSML that I had to manually paste into ElevenLabs:

The whole process took 5-10 minutes per card. It was exhausting.

The Spark: Chatterbox TTS

One day, someone mentioned Chatterbox—an open-source TTS model from Resemble AI that runs locally. Free. Unlimited. With voice cloning.

That got me thinking: What if I could automate the entire process?

So I started vibecoding.

What is Vibecoding?

Vibecoding is building software by describing what you want to an AI coding assistant and letting it write the code. You guide the “vibe” of what you want, iterate on the results, and end up with working software—often without writing much code yourself.

I used Claude Code (Anthropic’s CLI tool) to build this entire app. The process was conversational: I described features, Claude wrote the code, I tested it, and we iterated.

The Result: One-Click Flashcard Generation

Now, creating a card looks like this:

1. Type a word or phrase
2. Click “Generate All”
3. Done.

The app automatically:

• Generates a definition using Cambridge Dictionary style
• Creates a cloze example with proper markup
• Produces an image prompt describing the example scene
• Generates an anime-style image from the prompt
• Adds text overlay with the phrase
• Creates audio with natural pauses using SSML

And the final card in Anki:

How It Works: Prompt Engineering on Foundation Models

The magic is prompt engineering—crafting specific instructions that foundation models follow to produce consistent, high-quality outputs.

Text Generation (Multiple LLM Providers)

The app supports several LLM providers:

Behind the scenes, when you click “Generate All”, the app runs something like:

result = subprocess.run(
    ["claude", "-p", prompt, "--no-session-persistence"],
    capture_output=True,
    text=True,
    timeout=self.timeout
)

The prompt itself is carefully engineered:

system_prompt: |
  You are a vocabulary expert creating English learning flashcards.
  You always respond with valid JSON matching the exact schema requested.

  CRITICAL FOR EXAMPLES:
  - Each example MUST correctly demonstrate the definition's meaning
  - For IDIOMS: Use the FIGURATIVE meaning, not the literal meaning
  - Test: "Would a native English speaker use this phrase exactly this way?"

Image Generation (Multiple Providers)

The app generates an image prompt, then sends it to your chosen provider:

Audio Generation (TTS Providers)

For audio, you can choose between:

The app handles SSML parsing, pause timing, and audio normalization automatically.

audio_generator = self.client.text_to_speech.convert(
    text=processed_text,
    voice_id=voice_id,
    model_id="eleven_multilingual_v2",
    voice_settings=voice_settings,
)

Bonus: Custom Voice Cloning

Want to learn with a familiar voice? The app supports voice cloning using Chatterbox. You can:

1. Record your own voice (or a friend’s with permission)
2. Upload an audio file as a reference sample
3. Extract audio from YouTube for royalty-free content or personal samples
4. Generate all your flashcards with that custom voice

The app even analyzes audio quality and recommends optimal clip length (10-30 seconds) for best results.

What About Anki?

Anki is a free, open-source flashcard app that uses Spaced Repetition System (SRS) to optimize learning. Based on the forgetting curve research by Hermann Ebbinghaus, SRS shows you cards just before you’re about to forget them.

The app connects directly to Anki via AnkiConnect, so cards are added with one click—no manual import needed.

Foundation Models Summary

Here’s what powers the app:

Conclusion

What used to take 5-10 minutes per card now takes 10 seconds. And the quality is better because the prompts are refined and consistent.

This project is a perfect example of what’s possible when you combine:

• Prompt engineering to guide AI behavior
• Foundation models from multiple providers
• Vibecoding to build the app itself
• Local and cloud tools like Gradio, Chatterbox, and AnkiConnect

The future of personal productivity tools is building exactly what you need, with AI as your coding partner.

Have questions or want to discuss AI-powered learning tools? Feel free to reach out on LinkedIn.

The other day, while working on a critical refactoring task, Claude Code suddenly stopped responding. The familiar token consumption animation froze, requests timed out, and my productivity ground to a halt. If you’ve experienced this frustrating scenario—watching tokens not being consumed while your deadline approaches—you’re not alone.

The culprit? API issues with specific Anthropic models. The solution? Understanding how to diagnose the problem, switch between Claude’s model family, and leverage fallback options. Here’s what I learned during my unexpected deep dive into Claude Code’s model flexibility.

🔴 The Silent Failure: When Tokens Don’t Flow

The first sign something was wrong came subtly. I sent a request to refactor a complex Terraform module, and instead of the usual immediate response, I saw:

• No token consumption in the Claude Code interface
• Spinning request indicators that never resolved
• Failed requests with vague “API unavailable” messages

What made this particularly confusing was that it wasn’t a complete outage—Claude Code was running, authenticated properly, and showed no obvious errors. It was just… silent.

The Investigation Process

My first instinct was to check the usual suspects:

1. Network connectivity: Everything else worked fine
2. API key validity: Still active and authenticated
3. Claude Code version: Up to date
4. Local configuration: No recent changes

Nothing seemed wrong on my end, which led me to the critical question: Is this a problem with Anthropic’s services?

🔍 Checking Anthropic’s Status Page

This is where many developers get stuck—they assume the problem is local and spend hours troubleshooting their setup. The reality is that cloud services experience issues, and Anthropic is no exception.

The first step in diagnosing mysterious API timeouts: Check the status page.

Head to status.anthropic.com and look for incident reports or degraded performance indicators.

Anthropic status page showing Opus 4.5 and Haiku 4.5 experiencing issues

In my case, the status page immediately revealed the problem:

• Claude Opus 4.5: Experiencing elevated error rates
• Claude Haiku 4.5: Partial outage with API timeouts
• Claude Sonnet 4.5: Operational

This explained everything. I was using Opus 4.5 for complex reasoning tasks, and it was currently experiencing service degradation. The tokens weren’t being consumed because the model wasn’t responding—but critically, other Claude models were still available.

Why Status Pages Matter

In the world of AI-assisted development, we’ve become so dependent on these tools that outages feel catastrophic. But understanding that:

1. Individual models can experience issues while others remain operational
2. Planned maintenance happens regularly (check the status page for schedules)
3. Partial outages are often model-specific, not platform-wide

This knowledge transforms a productivity-killing mystery into a solvable problem with a clear action plan: switch models.

🔄 The Solution: Switching to Sonnet 4.5

Claude Code offers a powerful feature that many users overlook: the ability to switch between models on the fly. Anthropic’s model family includes:

• Claude Opus 4.5: Maximum intelligence, best for complex reasoning, architecture decisions, and multi-step problem solving
• Claude Sonnet 4.5: Balanced performance and speed, excellent for most development tasks
• Claude Haiku 4.5: Fast and efficient, ideal for simple queries and quick iterations

When Opus and Haiku were experiencing issues, Sonnet became my lifeline.

How to Switch Models in Claude Code

The process is straightforward using the /model command:

# Check current model
/model

# Switch to Sonnet 4.5
/model sonnet

# Switch to Opus 4.5 (when it's working)
/model opus

# Switch to Haiku 4.5 for speed
/model haiku

Claude Code model selection interface with Sonnet 4.5 highlighted

The switch is instantaneous, and Claude Code seamlessly continues your conversation context with the new model. In my case, switching to Sonnet not only restored functionality but also provided surprisingly good results for my refactoring task.

Understanding Model Tradeoffs

Each model has distinct characteristics that make it suitable for different scenarios:

Claude Opus 4.5:

• Strengths: Complex architecture, multi-file refactoring, nuanced debugging
• Weaknesses: Slower responses, higher cost, occasional availability issues
• Best for: Critical features, architectural decisions, intricate problem-solving

Claude Sonnet 4.5:

• Strengths: Fast, reliable, excellent code quality, great balance
• Weaknesses: May struggle with extremely complex reasoning chains
• Best for: Most development tasks, feature implementation, bug fixes

Claude Haiku 4.5:

• Strengths: Blazing fast, cost-effective, great for iterations
• Weaknesses: Limited context understanding, simpler reasoning
• Best for: Quick fixes, documentation, simple queries

In my experience, Sonnet 4.5 handles 80-90% of development tasks brilliantly, making it the perfect fallback when premium models experience issues.

🛡️ Building Resilience: The Value of Model Options

This incident highlighted a crucial insight: having model flexibility isn’t just about optimization—it’s about continuity. When you’re relying on AI for development work, a single point of failure can derail your entire workflow.

The Three-Tier Resilience Strategy

I now approach Claude Code with a resilience mindset:

Tier 1: Primary Model Selection

• Use Opus 4.5 for genuinely complex tasks requiring deep reasoning
• Default to Sonnet 4.5 for standard development work
• Reserve Haiku 4.5 for rapid iterations and simple queries

Tier 2: Model Switching Within Anthropic

• Monitor response times and token consumption
• Switch models at first sign of degraded performance
• Check status page when experiencing timeouts

Tier 3: Alternative AI Providers (discussed below)

• Have backup providers configured and ready
• Understand which alternatives excel at specific tasks
• Maintain API access to multiple platforms

This strategy ensures that an issue with a single model—or even a single provider—doesn’t stop your work.

🌐 Beyond Anthropic: Fallback to Other AI Providers

While Claude Code is tightly integrated with Anthropic’s models, there are times when you need to go beyond the ecosystem entirely. Perhaps all Anthropic models are experiencing issues, you’ve hit usage limits, or you need capabilities specific to another provider.

Available Fallback Options

Google Gemini:

• Access: Direct API or through Claude Code Router with OpenRouter
• Strengths: Excellent code generation, strong at structured outputs, competitive pricing
• Best for: When you need Google’s ecosystem integration or specific Gemini features
• Setup: Configure via OpenRouter or direct Gemini API

OpenAI Codex / GPT Models:

• Access: Through Claude Code Router + OpenRouter
• Strengths: GPT-4o excels at complex reasoning, GPT-4o-mini is cost-effective
• Best for: Tasks where you’ve found GPT performs better, or when exploring model differences
• Note: GPT-5 requires BYOK (Bring Your Own Key) on OpenRouter

Qwen (Alibaba):

• Access: Free tier available on OpenRouter
• Strengths: Qwen3 Coder optimized for development tasks, massive 262K context window
• Best for: Cost-conscious development, experimenting with Chinese tech stack models
• Surprising quality: Free doesn’t mean inferior—Qwen handles routine tasks remarkably well

DeepSeek:

• Access: Free on OpenRouter, also available through API
• Strengths: Strong reasoning capabilities, particularly good for debugging
• Best for: When you need fresh perspective on complex bugs
• Bonus: Open-weight model with solid general performance

Setting Up Claude Code Router for Multi-Provider Access

To access these alternatives, you’ll need Claude Code Router—a powerful proxy that routes Claude Code requests to any compatible LLM provider.

Quick Setup:

# Install Claude Code Router
npm install -g @musistudio/claude-code-router

# Start the router
ccr start

# Open the configuration UI to set up providers
ccr ui

The router UI at http://localhost:3456 provides visual configuration for routing rules, letting you assign specific models to different scenarios (Default, Background, Think, Long Context).

For a comprehensive guide on setting up Claude Code Router with OpenRouter, including detailed configuration examples and advanced routing strategies, check out my previous post: Claude Code Router and OpenRouter: Beyond Anthropic.

When to Use Alternative Providers

Immediate Fallback Scenarios:

• All Anthropic models experiencing issues (check status page)
• Hit Claude usage limits mid-project
• Specific task better suited to another model (e.g., GPT for certain types of creative writing)

Strategic Use Cases:

• Cost optimization: Use free Qwen/DeepSeek for routine tasks, save Claude credits for complex work
• Model comparison: Test same task across providers to find best fit
• Privacy requirements: Self-hosted Ollama for sensitive code
• Experimentation: Explore different model capabilities and approaches

Important Consideration: Not all models support Claude Code’s tool/function calling features. Many free models excel at code generation and explanation but can’t execute file operations or git commands. Route accordingly:

• Tool-capable: Claude models, GPT-4o series, some Gemini models
• Text-only: Most free models (great for explanations, reviews, documentation)

💡 Lessons Learned: Best Practices for Resilient AI Development

After this experience, I’ve adopted several practices that have made my AI-assisted workflow more robust:

1. Monitor, Don’t Assume

Before this incident, I assumed timeouts were always local issues—my network, my configuration, my code.

Now, my troubleshooting checklist starts with:

1. Check Anthropic status page
2. Test model switching
3. Verify network/configuration
4. Consider alternative providers

This simple reordering saves hours of misdirected debugging.

2. Diversify Your Model Strategy

Don’t over-optimize for a single model. I used to default to Opus for everything, thinking “more powerful = better results.” This created:

• Higher costs
• Slower responses
• Single point of failure

Now, I match models to task complexity:

• Haiku for quick iterations and documentation
• Sonnet for standard feature development
• Opus reserved for genuinely complex architectural work

This approach is faster, cheaper, and more resilient.

3. Maintain Provider Optionality

Even if you primarily use Anthropic models, having Claude Code Router configured with alternatives provides peace of mind. I keep:

• OpenRouter account with $10 credit (lasts months with free models)
• Gemini API key for Google ecosystem tasks
• Local Ollama for privacy-sensitive work

I rarely use these alternatives, but when I need them—during outages or for specific capabilities—they’re immediately available.

4. Understand Usage Patterns

Track which models you actually need for different tasks. I discovered:

• 70% of my queries work perfectly with Sonnet
• 20% benefit from Opus’s reasoning
• 10% are simple enough for Haiku

This awareness helps with both model selection and cost management.

5. Bookmark the Status Page

Add status.anthropic.com to your bookmarks. When you encounter issues:

• Check status page FIRST
• Save time troubleshooting phantom problems
• Understand incident scope and ETA

It seems obvious in hindsight, but it’s easy to forget during a frustrating timeout scenario.

🔧 Practical Troubleshooting Workflow

When you encounter API timeouts or unresponsive behavior in Claude Code, follow this systematic approach:

Step 1: Quick Diagnostics (2 minutes)

# Check current model
/model

# Verify Claude Code status
claude status

# Check your usage/limits
# (Available in Claude Code UI or API dashboard)

Step 2: Status Verification (1 minute)

• Open status.anthropic.com
• Look for incidents affecting your current model
• Note any planned maintenance windows

Step 3: Model Switch Test (1 minute)

# Try switching to different Anthropic model
/model sonnet

# Send a simple test query
"Hello, are you responding correctly?"

If this works, the issue is model-specific. Continue with the working model.

Step 4: Alternative Provider (if needed)

If all Anthropic models are affected:

# Launch Claude Code Router (if configured)
ccr start

# Switch to alternative via router
/model openrouter,gemini-2.0-flash-exp

# Continue your work

Step 5: Long-term Resolution

• Monitor status page for all-clear
• Switch back to preferred model when available
• Consider adjusting default model based on reliability patterns

🧠 Final Thoughts: Embrace Model Diversity

The myth of the “perfect AI model” is just that—a myth. The reality is more nuanced:

• Different models excel at different tasks
• Availability and reliability vary over time
• Cost considerations matter for sustainable usage
• Privacy and security requirements differ by project

My API timeout experience was frustrating in the moment, but it led to a valuable realization: the most powerful feature of Claude Code isn’t access to the best model—it’s the flexibility to choose the right model for right now.

Key Takeaways

1. Status pages are your friend: Check status.anthropic.com when issues arise
2. Model switching is simple: Use /model command to switch between Sonnet, Opus, and Haiku
3. Sonnet is underrated: The “balanced” model handles most tasks brilliantly
4. Build fallback options: Configure Claude Code Router for multi-provider access
5. Match models to tasks: Don’t use Opus for everything just because it’s “premium”
6. Systematic troubleshooting saves time: Follow a consistent diagnostic process

What’s Next?

The AI development landscape continues to evolve rapidly. Features I’m watching:

• Automatic model failover: Claude Code detecting issues and switching models automatically
• Usage-based routing: Intelligent model selection based on remaining quotas
• Performance-based learning: Systems that learn which models you prefer for specific tasks
• Cross-provider context: Seamless conversation continuity across different AI providers

Until then, knowing how to manually navigate these scenarios keeps you productive regardless of what the status page shows.

📚 References

• Anthropic Status Page - Real-time service status for Claude models
• Claude Code Documentation - Official setup and usage guides
• Claude Code Router - Multi-provider routing for Claude Code
• OpenRouter - Universal API gateway for 400+ AI models
• Model Context Protocol - Standardized AI tool integration
• Ollama - Run AI models locally for maximum privacy

Have you experienced API timeouts with Claude Code or other AI assistants? What’s your fallback strategy when your primary model isn’t available? Share your experiences and troubleshooting tips in the comments below.

Last week, I stumbled upon Pico-8 while browsing retro gaming communities. As someone who plays classic games on handheld devices like the Miyoo Mini Plus and Anbernic consoles, the idea of a “fantasy console” immediately caught my attention. But here’s the thing—I had zero interest in learning Lua or spending weeks mastering Pico-8’s constraints.

So I thought: what if I just “code-vibe” with Claude Code to build a complete game? No tutorials, no language learning, just pure AI-assisted development. The result? A fully functional Mastermind game where the code works flawlessly but the art… well, let’s just say AI hasn’t figured out pixel art yet.

This isn’t about AI replacing developers. It’s about understanding what AI can do exceptionally well (code logic) and where it completely falls apart (artistic creativity). Here’s what I learned from building a Pico-8 game without knowing the language.

🎮 What is Pico-8?

Pico-8 is a fantasy console—an imaginary video game system with intentional limitations that spark creativity. Think of it as what the Game Boy could have been if it had perfect programming tools and a vibrant online community.

The Beautiful Constraints

• Display: 128x128 pixels
• Colors: 16-color palette
• Sound: 4-channel chip tune synthesizer
• Code: 8,192 tokens of Lua
• Sprites: 256 8x8 pixel sprites
• Map: 128x64 tile map

These limitations aren’t bugs—they’re features. They force you to be creative, to make every pixel count, and to build games that feel genuinely retro. The Pico-8 community has created thousands of games, from platformers to RPGs to puzzle games, all within these constraints.

What really appealed to me was that Pico-8 games run everywhere—not just on desktop, but on handheld retro gaming devices like the Miyoo Mini Plus, Anbernic RG35XX, and other pocket-sized consoles that support custom firmware. There’s something magical about creating a game on your laptop and playing it on a tiny handheld device an hour later.

🤖 The Experiment: Code-Vibing with Claude Code

I wanted to build a Mastermind game—the classic code-breaking puzzle where you guess a secret pattern of colored pegs. The game gives you feedback after each guess: black pegs for correct colors in correct positions, white pegs for correct colors in wrong positions.

My approach was simple: describe what I wanted, let Claude Code do the heavy lifting, and iterate based on testing.

The Development Process

Phase 1: Core Game Logic

Me: "Create a Pico-8 Mastermind game with 4 colors and 6 attempts."
Claude: *Generates complete game logic with initialization, input handling, and feedback*

Within minutes, I had working code that:

• Generated random secret codes
• Handled player input for selecting colors
• Calculated feedback (correct position vs correct color)
• Managed game state (playing, won, lost)
• Displayed the game board and attempts

Here’s a simplified snippet of what Claude Code generated:

function _init()
    secret={flr(rnd(6))+1,flr(rnd(6))+1,
            flr(rnd(6))+1,flr(rnd(6))+1}
    attempts={}
    current_guess={1,1,1,1}
    cursor=1
    game_state="playing"
end

function _update()
    if game_state=="playing" then
        if btnp(⬅️) then cursor=max(1,cursor-1) end
        if btnp(➡️) then cursor=min(4,cursor+1) end
        if btnp(⬆️) then current_guess[cursor]=(current_guess[cursor]%6)+1 end
        if btnp(⬇️) then current_guess[cursor]=((current_guess[cursor]-2)%6)+1 end
        if btnp(🅾️) then submit_guess() end
    end
end

Phase 2: Polish and Features

Me: "Add a title screen and instructions."
Claude: *Implements menu system with game flow*

Me: "Show the secret code when the game ends."
Claude: *Adds reveal logic with proper game state handling*

Me: "Make the feedback clearer with different symbols."
Claude: *Updates rendering to use distinct visual indicators*

The code just… worked. Every iteration was functional. No syntax errors, no logic bugs, no weird edge cases. Claude Code understood Pico-8’s limitations and API perfectly.

What Impressed Me About the Code

1. Proper Pico-8 conventions: Used _init(), _update(), _draw() correctly
2. Efficient token usage: Code stayed well under the 8,192 token limit
3. Clean state management: Game states transitioned smoothly
4. Input handling: Button presses felt responsive and natural
5. Edge cases handled: Prevented invalid moves and game state corruption

I literally wrote zero lines of Lua. I just described features in natural language, and Claude Code translated my intent into working game logic.

🎨 Where AI Hit the Wall: The Art Problem

Now here’s where things got interesting—and by interesting, I mean hilariously broken.

Me: "Let's make the UI look more retro, give it that 80s arcade style."
Claude: *Generates updated graphics with retro styling*

Me: "The lines are overlapping and the chips look weird."
Claude: *Tries again, visual bugs persist*

Me: "Can you fix the overlapping elements?"
Claude: *Third attempt, still introducing visual glitches*

The sprites were a mess. Colors bled into each other, shapes didn’t align properly, and the overall aesthetic looked like a glitch art project gone wrong.

Why AI Fails at Pixel Art

After multiple iterations, I realized the fundamental problem: Claude Code (and current general-purpose AI models) lack spatial-visual reasoning for pixel-level design.

The AI could:

• ✅ Generate perfect code logic
• ✅ Understand game mechanics
• ✅ Handle complex state management
• ✅ Optimize for Pico-8’s constraints

But it couldn’t:

• ❌ Visualize how pixels form recognizable shapes
• ❌ Understand aesthetic coherence
• ❌ Apply consistent design language
• ❌ Create sprites that “feel” like game assets

Important distinction: This limitation is specific to current general-purpose AI models like Claude Sonnet 4.5. Specialized AI art tools like Stable Diffusion, DALL-E, or Midjourney excel at image generation, but they aren’t integrated into coding workflows and don’t understand Pico-8’s specific pixel format constraints.

The Pragmatic Decision

Here’s where the “code-vibing” philosophy hit a wall. Fixing the visual bugs would have required diving deep into the sprite code, understanding how AI had structured the graphics, and manually debugging pixel-level issues. That’s the opposite of code-vibing—it defeats the whole purpose of building without learning the underlying implementation.

So I made a practical choice: I published the game with the original, clean design from before I asked for the 80s retro styling. The initial AI-generated graphics were simple but functional. The “improved” versions introduced bugs I couldn’t easily fix without breaking the code-vibing approach.

This taught me something crucial: AI dramatically accelerates code development, but artistic “improvements” can introduce complexity that requires deep technical knowledge to fix. When AI visual changes break things, you either need to understand the code deeply (losing the code-vibing benefit) or revert to what worked. I chose the latter.

🛠️ What I Actually Learned: The Pico-8 Console

While Claude Code handled the coding, I still had to learn Pico-8’s development environment. The console commands became my daily tools:

# Load and run your game
load mastermind.p8
run

# Save your work
save

# Export to web or binary
export mastermind.html
export mastermind.bin

# Sprite and map editors
# Press ESC to toggle between code and sprite editor

# Sound and music tools
# Use the music editor to create chip tune soundtracks

# Debug commands
printh("debug: "..tostr(value))  -- Print to console
stop()  -- Pause execution

Essential Workflow Commands

Development cycle:

1. Edit code or sprites in Pico-8
2. Press Ctrl+R to run immediately
3. Test gameplay and identify issues
4. Press ESC to return to editor
5. Iterate

Publishing:

# Create web playable version
export mastermind.html

# Create standalone binary
export mastermind.bin

# Export to PNG (code + sprites embedded)
save mastermind.p8.png

The console became my primary interface. While Claude Code wrote the logic, I was constantly running, testing, and tweaking based on how the game actually felt to play.

🚀 Publishing the Game: From Local to Lexaloffle

Once the game was playable and the art was fixed, I published it to the Pico-8 community platform: BBS Lexaloffle.

The publishing process was surprisingly straightforward:

1. Create an account on Lexaloffle BBS
2. Export the cartridge as a PNG file (save mastermind.p8.png)
3. Upload to BBS with description and screenshots
4. Share with the community and gather feedback

What’s fascinating about Pico-8’s ecosystem is the cartridge format. Games are distributed as PNG images that contain the code, sprites, music, and map data. You can literally share a game as an image file, and other Pico-8 users can load and play it immediately.

The Community Response

Publishing on Lexaloffle gave me immediate access to:

• Playable web version: Anyone can play directly in their browser
• Download options: Users can grab the .p8 file and run it locally
• Community feedback: Other developers provide suggestions and bug reports
• Discoverability: Games appear in the BBS feed and search results

The Pico-8 community is incredibly welcoming to newcomers. Despite my game being a simple Mastermind implementation built with AI assistance, people played it, left encouraging comments, and even suggested improvements.

🎯 The Bigger Picture: What This Means for Development

This experiment revealed something important about AI-assisted development in 2025: we’re entering an era of “code-vibing” where developers can create functional software in languages they don’t formally know.

The New Development Model

Traditional Approach:

1. Learn language syntax and conventions
2. Study framework documentation
3. Write code manually
4. Debug and iterate
5. Optimize and polish

AI-Assisted Approach:

1. Describe what you want in natural language
2. AI generates functional code
3. Test and provide feedback
4. AI iterates based on your input
5. You focus on design and experience

When Code-Vibing Works

This approach excels when:

• ✅ The problem domain is well-defined (game logic)
• ✅ The language has clear conventions (Pico-8 API)
• ✅ You can test and validate quickly (run the game)
• ✅ Documentation exists for the AI to reference
• ✅ Logic matters more than creative assets

When Code-Vibing Fails

The approach struggles with:

• ❌ Visual/artistic creativity (sprites, animations)
• ❌ Highly subjective design decisions (UI aesthetics)
• ❌ Novel problems without existing patterns
• ❌ Domains requiring specialized expertise
• ❌ Physical or spatial reasoning tasks

The Hybrid Reality

The future isn’t “AI replaces developers”—it’s “AI handles code, humans handle creativity.”

For my Pico-8 game:

• AI-generated: All game logic, state management, input handling
• Human-created: Sprites, color schemes, game feel, design decisions

This division makes sense. AI excels at structured, logical tasks with clear rules. Humans excel at creative, aesthetic, and experiential decisions.

💡 Key Takeaways for Developers

After building this game, here’s what I learned about AI-assisted development:

1. AI Coding is Genuinely Excellent

Claude Code didn’t just generate working code—it generated good code. Proper conventions, clean structure, efficient logic. I could have written this myself after learning Lua, but it would have taken significantly longer.

2. Art is Still a Human (or Specialized AI) Domain

General-purpose AI models struggle with pixel-level visual design. You’ll need:

• Manual sprite creation
• Specialized AI art tools (Stable Diffusion, DALL-E)
• Collaboration with actual artists

3. You Still Need Domain Understanding

Even though I didn’t write Lua, I needed to:

• Understand Pico-8’s constraints
• Test the game and identify issues
• Communicate feedback clearly
• Make design decisions

Code-vibing isn’t passive—it’s an active collaboration where you guide the AI’s output.

4. Iteration is Fast and Painless

Traditionally, making changes requires:

• Finding the right code section
• Understanding existing implementation
• Rewriting logic
• Testing for regressions

With AI assistance:

• Describe the change in natural language
• AI implements the modification
• Test immediately
• Iterate until perfect

5. The Learning Curve Shifts

Instead of learning:

• Language syntax
• Framework APIs
• Common patterns

You learn:

• How to describe problems clearly
• How to test and validate effectively
• How to guide AI iterations
• Domain-specific knowledge

This is a different skill set, but arguably more valuable in an AI-assisted world.

🔮 Getting Started with Pico-8 and AI Development

If this experiment inspired you to try building your own Pico-8 game with AI assistance, here’s how to start:

Prerequisites

1. Get Pico-8: Purchase from Lexaloffle ($15)
2. Install Claude Code: Free for basic usage, Pro for unlimited
3. Optional: Retro handheld device for testing (Miyoo Mini Plus, Anbernic)

Your First AI-Generated Game

Week 1: Simple Game Loop

Prompt: "Create a basic Pico-8 game with player movement and a game over screen."

Week 2: Add Mechanics

Prompt: "Add collision detection and score tracking."

Week 3: Polish

Prompt: "Add a title screen, instructions, and end game sequence."

Week 4: Manual Art Pass

• Open Pico-8’s sprite editor
• Create or refine visual assets
• Learn color palette constraints

Recommended First Projects

• Flappy Bird clone: Simple physics and collision
• Snake game: Grid-based movement and growth
• Memory matching: Card flipping and state management
• Breakout: Paddle movement and ball physics

Start simple, iterate quickly, and don’t stress about art until the gameplay feels right.

🧠 The Honest Assessment

Let me be clear about what this experiment proved and didn’t prove:

What Worked

• Code generation: Claude Code produced production-quality Lua code
• Rapid iteration: Changes happened in minutes, not hours
• Learning efficiency: I understood Pico-8 concepts without formal study
• Functional completeness: The game logic was genuinely good

What Didn’t Work

• Sprite generation: AI-created graphics were unusable
• Aesthetic decisions: AI couldn’t judge “good” vs “bad” design
• Creative direction: Human judgment was essential for game feel

The Limitation Reality

This isn’t about current AI being bad at art—it’s about the type of AI I used. General-purpose language models like Claude Sonnet 4.5 aren’t designed for pixel-perfect visual creation.

Specialized AI art tools exist and work well:

• Stable Diffusion: Excellent for concept art and illustrations
• DALL-E 3: Great for stylized game assets
• Midjourney: Perfect for background art and promotional images

But these tools:

1. Aren’t integrated into coding workflows yet
2. Don’t understand Pico-8’s specific sprite format
3. Require manual export and conversion processes

The future is hybrid workflows: AI for code, specialized tools or humans for assets, and human judgment for design decisions.

📚 Resources and Community

If you’re interested in exploring Pico-8 or AI-assisted game development further:

Pico-8 Learning

• Official Manual: Pico-8 User Manual
• Community Forums: BBS Lexaloffle
• Game Collection: Pico-8 Carts
• YouTube Tutorials: Lazy Devs Academy, Nerdy Teachers

AI Coding Tools

• Claude Code: Anthropic Claude
• GitHub Copilot: GitHub Copilot
• Cursor: Cursor IDE

Retro Handhelds

• Miyoo Mini Plus: Compact, affordable, great Pico-8 support
• Anbernic RG35XX: Popular choice with active community
• Retro Game Corps: Setup guides and reviews

Have you tried building games with AI assistance? What’s been your experience with AI-generated art versus code? I’d love to hear about your experiments and whether you’ve found better workflows for handling creative assets in AI-assisted development. Share your thoughts and projects in the comments below.

I stumbled upon GitHub Copilot CLI while catching up on tech news, and the native GitHub integration immediately caught my attention. A terminal-native AI assistant that can interact directly with repositories, issues, and PRs? I decided to give it a try to have in my AI toolbox.

Copilot CLI is the latest addition to GitHub’s Copilot ecosystem, joining Copilot in the IDE (code completion and chat), GitHub Copilot Workspace (issue-to-PR automation), and Copilot Extensions (custom integrations). This CLI component brings the Copilot experience directly to the terminal, complementing the ecosystem with command-line workflows. Here’s what I learned after testing it.

🚀 What is GitHub Copilot CLI?

GitHub Copilot CLI is GitHub’s terminal-native AI assistant that brings conversational AI directly to your command line. Think of it as ChatGPT for your terminal, but with direct access to your file system, MCP servers, and development context.

What Makes It Different

• Terminal-native interface: No browser, no context switching
• Interactive mode: Natural conversations with / commands
• MCP integration: Connect to Context7, GitHub, and custom MCP servers
• Model flexibility: Support for GPT-4o, GPT-5, and other OpenAI models
• Session management: Resume conversations and maintain context
• File system access: Direct file reading and analysis

Current Status: Public Preview

Copilot CLI is in public preview (version 0.0.332 at the time of writing), which means:

• Features are actively evolving
• Available to GitHub Copilot subscribers
• Some capabilities may change as it approaches stable release
• Feedback directly shapes the product direction

🔧 Quick Start: Installation & First Run

Getting started with Copilot CLI is straightforward:

# Install globally via npm
npm install -g @github/copilot

# Launch interactive mode
copilot

# Or use specific model
copilot --model gpt-5

# Quick one-shot queries
copilot -p "analyze terraform module" --allow-all-tools

Understanding the Configuration

Copilot CLI creates a configuration directory at ~/.copilot/ with the following structure:

~/.copilot/
├── command-history-state.json  # Command history tracking
├── config.json                  # User preferences and settings
├── history-session-state/       # Session state management
├── logs/                        # Debug and activity logs
└── mcp-config.json             # MCP server configurations

The mcp-config.json file is where MCP server integrations are stored. Each time you add an MCP server via /mcp add, this file is updated automatically.

💡 MCP Integration: The Game Changer

Here’s where Copilot CLI really shines—native MCP support that lets you connect to specialized AI servers and tools directly from your terminal.

Interactive MCP Commands

Once you’re in interactive mode (copilot), you have access to these MCP management commands:

/mcp add      # Add new MCP server interactively
/mcp show     # Display configured MCP servers
/mcp disable  # Temporarily disable a server
/mcp enable   # Re-enable a disabled server

Adding MCP Servers: The Interactive Way

The /mcp add command provides a guided setup experience. Let me show you how I added Context7 and GitHub MCP servers:

The interactive prompt walks you through:

1. Server Name: Unique identifier for the MCP server
2. Server Type: Local, HTTP, or SSE (Server-Sent Events)
3. Connection Details:
   • Local: Command to start the server (e.g., npx)
   • HTTP: Remote server URL
   • SSE: Server-sent events endpoint
4. Arguments: Command-line arguments for local servers
5. Environment Variables: Optional environment configuration
6. Tools Selection: Choose which tools to expose (* for all)

Real-World Example: Adding Context7

Here’s the actual workflow for adding Context7 MCP server:

Server Name: Context7
Server Type: [2] HTTP
URL: https://mcp.context7.com/mcp
HTTP Headers: (optional, for authentication)
Tools: * (all tools)

Once configured, Context7’s documentation search capabilities are immediately available in your Copilot CLI sessions.

Adding GitHub MCP Server

The GitHub MCP server provides repository access and operations:

As shown in the screenshot, once configured, you’ll see:

• Connected to GitHub MCP Server confirmation
• Server listed in your MCP configuration
• Available tools and capabilities

This gives you direct access to:

• Repository information and file access
• Pull request and issue operations
• GitHub Actions workflow data
• Commit history and branch management

MCP Configuration Persistence

All MCP servers are saved to ~/.copilot/mcp-config.json, making them available across all sessions. Your configuration persists and automatically loads when you start Copilot CLI.

🎯 Essential Interactive Commands

Beyond MCP management, Copilot CLI provides powerful session control commands:

Model Selection

/model gpt-5              # Switch to GPT-5 for current session
/model gpt-4o             # Use GPT-4o for general tasks
/model gpt-5 --reasoning  # Enable extended reasoning mode

File System Access

/add-dir ~/projects       # Grant access to specific directory
/add-dir ~/terraform      # Add Terraform configurations
/add-file config.yaml     # Add individual file to context

Session Management

/cwd ~/terraform          # Change working directory
/session                  # View current session info
/resume                   # Resume previous session
/history                  # Show command history

Feedback & Help

/feedback                 # Provide feedback to GitHub
/help                     # Show all available commands
/exit                     # Exit interactive mode

🛠️ Real-World DevOps Workflow

Here’s a practical scenario showing Copilot CLI in action:

Scenario: Terraform Module Analysis

# Start Copilot CLI in your Terraform directory
cd ~/git/terraform-aws-ecrpublic
copilot --model gpt-5

# Interactive session begins
> "Analyze the module structure and suggest improvements"

# Use MCP to fetch documentation
> "Using Context7, find AWS ECR Public best practices"

# Check GitHub workflows
> "Show me the GitHub Actions workflows for this repo"

# Generate summary
> "Create a summary of potential security improvements"

# Save session for later
> /feedback "This analysis was helpful for security audit"

Command-Line Flags for Automation

For CI/CD or scripted workflows:

# Allow all file system operations (for automation)
copilot -p "analyze terraform validation output" --allow-all-tools

# Resume previous session
copilot --resume --model gpt-5

# Add specific directory access
copilot --add-dir ~/terraform -p "review module configuration"

# Specify model and context
copilot --model gpt-4o --cwd ~/projects/api -p "analyze API performance"

⚖️ When to Use: Copilot CLI vs Claude Code vs Cursor CLI

After using all three terminal-based AI tools, here’s my decision framework:

GitHub Copilot CLI

Best for:

• ✅ Terminal-native workflows (no context switching)
• ✅ MCP server integration and orchestration
• ✅ GitHub-centric development workflows
• ✅ Interactive debugging sessions
• ✅ OpenAI model ecosystem (GPT-4o, GPT-5)

Characteristics:

• Strong MCP support: Native integration with interactive management
• GitHub integration: Direct repository and Actions access
• Model selection: Easy model switching during sessions
• Session persistence: Resume and continue conversations

Claude Code

Best for:

• ✅ Complex multi-step reasoning and planning
• ✅ Code implementation with tool use
• ✅ Sequential thinking workflows
• ✅ Anthropic’s Claude models (Sonnet, Opus)
• ✅ Extensive file editing and refactoring

Characteristics:

• Agentic capabilities: Can use tools and implement changes
• Claude models: Access to Anthropic’s model family
• Rich context: Strong codebase understanding
• Subagents: Specialized agent workflows

Cursor CLI

Best for:

• ✅ Quick code generation and snippets
• ✅ Cursor IDE integration
• ✅ Simple terminal queries
• ✅ Fast model responses

Characteristics:

• IDE integration: Works with Cursor editor
• Speed focus: Quick responses for simple tasks
• Cursor ecosystem: Part of Cursor’s suite of tools

Decision Matrix

🔥 Pro Tips for Maximum Productivity

1. Leverage --allow-all-tools for CI/CD

In automated environments, grant full access to avoid interactive prompts:

# CI/CD pipeline usage
copilot -p "analyze test coverage report" \
  --allow-all-tools \
  --model gpt-5 \
  --add-dir ./coverage

2. Use --resume for Session Continuation

Don’t start from scratch—resume your previous context:

# Continue where you left off
copilot --resume --model gpt-5

# Resume and add new context
copilot --resume --add-dir ~/new-project

3. Combine --add-dir with MCP Servers

Grant file access and leverage MCP capabilities simultaneously:

copilot --add-dir ~/terraform \
  --model gpt-5 \
  -p "Using Context7, analyze this Terraform module against AWS best practices"

4. Interactive /mcp Commands for Dynamic Workflows

Add MCP servers on-the-fly during interactive sessions:

# In interactive mode
> /mcp add
# Configure new server interactively

> /mcp show
# Verify all connected servers

> "Now use the newly added server to analyze X"

5. Model Switching During Sessions

Change models mid-conversation based on task complexity:

# Start with GPT-4o for general analysis
copilot --model gpt-4o

# Switch to GPT-5 for complex reasoning
> /model gpt-5

# Continue with enhanced reasoning capabilities
> "Now perform deep security analysis of the authentication flow"

📊 Quick Takeaways

After a week of intensive usage, here’s what stands out:

✅ Terminal-native AI: Finally, a conversational AI that lives where developers work ✅ MCP integration: Best-in-class MCP support with interactive management ✅ Session persistence: Resume conversations and maintain context across sessions ✅ Model flexibility: Easy switching between GPT-4o, GPT-5, and other models ✅ GitHub ecosystem: Native integration with repositories and Actions

⚠️ Public preview status: Features evolving, expect some rough edges ⚠️ Limited to OpenAI models: No Anthropic Claude or other model providers (yet) ⚠️ Guidance-focused: Provides analysis and suggestions rather than direct code implementation

🎯 Getting Started: Your First Week

Day 1: Basic Setup

# Install Copilot CLI
npm install -g @github/copilot

# Launch and explore interactive mode
copilot

# Try basic commands
> /help
> /model gpt-5
> "Hello, analyze my current directory structure"

Day 2-3: MCP Integration

# Add your first MCP server
copilot
> /mcp add

# Configure Context7 or GitHub MCP
# Server Name: Context7
# Type: HTTP
# URL: https://mcp.context7.com/mcp

# Test the integration
> "Using Context7, find documentation on Terraform AWS modules"

Day 4-5: Real Workflow Integration

# Use in actual development workflow
cd ~/your-project
copilot --model gpt-5 --add-dir .

# Analyze, debug, and iterate
> "Analyze the test coverage in this project"
> "What security improvements can be made?"
> "Review the CI/CD workflow configuration"

Week 1: Automate Common Tasks

# Create aliases for frequent workflows
alias copilot-tf="copilot --add-dir . --model gpt-5 -p 'Analyze Terraform configuration'"
alias copilot-debug="copilot --resume --allow-all-tools"

# Use in CI/CD
copilot -p "analyze build logs" --allow-all-tools --model gpt-5

🔮 The Bottom Line

GitHub Copilot CLI represents a significant shift in how we interact with AI during development. By bringing conversational AI directly to the terminal with native MCP support, it eliminates context switching and enables truly integrated workflows.

Choose Copilot CLI when you need:

• Terminal-native AI without leaving your workflow
• MCP server orchestration with interactive management
• GitHub repository and Actions integration
• Session persistence and resume capabilities
• OpenAI model ecosystem access

The public preview status means:

• Features are actively improving
• Your feedback shapes the product
• Some rough edges still exist
• Early access to cutting-edge capabilities

Copilot CLI is a valid alternative for terminal-based development, especially if you’re already using GitHub Copilot. The native GitHub integration, combined with MCP extensibility, makes it a natural choice for workflows that center around GitHub repositories, issues, and pull requests.

Start with the basics, add one MCP server, and see how terminal-native AI changes your workflow. You might find yourself reaching for the browser less and solving problems faster—right from where you’re already working.

📚 Resources

• GitHub Copilot CLI Documentation
• Model Context Protocol Specification
• Context7 MCP Server
• GitHub MCP Server

Have you tried GitHub Copilot CLI yet? What MCP servers are you integrating? Share your terminal-native AI workflows in the comments below.

I stumbled upon GitHub Models while browsing GitHub’s latest features and decided to give it a try. What caught my attention wasn’t just another AI API—it was the seamless integration with GitHub Actions and the fact that it’s completely free for most development workflows.

After experimenting with it for a while, I realized GitHub Models fills a specific niche: simple, direct AI integration without the complexity of setting up external services or managing API keys. Here’s what I learned and how it compares to more sophisticated solutions.

🚀 What is GitHub Models?

GitHub Models is GitHub’s native AI inference service that provides free access to enterprise-grade models directly within your repositories. Think of it as AI-as-a-Service, but built into the platform where your code already lives.

Key Models Available

• OpenAI GPT-4o: Best for complex analysis and reasoning
• GPT-4o mini: Faster, cost-effective for simpler tasks
• Meta Llama 3.1 (8B, 70B, 405B): Open-source alternatives
• Microsoft Phi 3: Efficient for quick responses
• Mistral Large: Multilingual and specialized reasoning

What Makes It Different

• Zero external setup: Uses your GitHub credentials
• Free tier: 50,000 tokens/month across all models
• Native Actions integration: No API keys in secrets
• Privacy-first: Your prompts don’t train the models

🔧 Getting Started: The Official GitHub Approach

The simplest way to use GitHub Models is through direct API calls in GitHub Actions. Here’s the basic setup:

Authentication Setup

GitHub Models uses your repository’s built-in GITHUB_TOKEN with the models: read permission:

name: AI Analysis Workflow

on: [push, pull_request]

permissions:
  contents: read
  models: read  # Required for GitHub Models

jobs:
  ai-analysis:
    runs-on: ubuntu-latest
    steps:
      - name: Analyze with AI
        env:
          GITHUB_TOKEN: $
        run: |
          curl -X POST "https://models.github.ai/inference/chat/completions" \
            -H "Content-Type: application/json" \
            -H "Authorization: Bearer $GITHUB_TOKEN" \
            -d '{
              "model": "openai/gpt-4o",
              "messages": [
                {"role": "user", "content": "Analyze this for potential issues"}
              ]
            }'

Using actions/ai-inference Action

GitHub provides an official action that simplifies the API calls:

- name: Run AI Analysis
  id: ai-analysis
  uses: actions/ai-inference@v1
  with:
    model: 'gpt-4o'
    system-prompt: 'You are a DevOps engineer reviewing infrastructure'
    prompt: |
      Analyze the following Terraform validation results:
      $

      Provide:
      1. Overall assessment
      2. Key findings
      3. Recommendations
      4. Security considerations

🎯 Real-World Examples

1. Intelligent Bug Report Analysis

This workflow analyzes bug reports to determine if they contain enough information for reproduction:

name: Bug Report Analysis

on:
  issues:
    types: [opened, edited]

permissions:
  issues: write
  models: read

jobs:
  analyze-bug-report:
    if: contains(github.event.issue.labels.*.name, 'bug')
    runs-on: ubuntu-latest

    steps:
    - name: Analyze Bug Report
      env:
        GITHUB_TOKEN: $
      run: |
        ISSUE_CONTENT="$ - $"

        ANALYSIS=$(curl -s -X POST "https://models.github.ai/inference/chat/completions" \
          -H "Content-Type: application/json" \
          -H "Authorization: Bearer $GITHUB_TOKEN" \
          -d "{
            \"model\": \"openai/gpt-4o\",
            \"messages\": [
              {
                \"role\": \"system\",
                \"content\": \"Analyze bug reports for reproduction feasibility. Return JSON with reproducible (boolean), missing_info (array), and confidence (0-1).\"
              },
              {
                \"role\": \"user\",
                \"content\": \"$ISSUE_CONTENT\"
              }
            ],
            \"max_tokens\": 500
          }")

        REPRODUCIBLE=$(echo "$ANALYSIS" | jq -r '.choices[0].message.content' | jq -r '.reproducible')

        if [ "$REPRODUCIBLE" = "true" ]; then
          gh issue edit $ --add-label "ready-for-reproduction"
        else
          gh issue edit $ --add-label "needs-more-info"
        fi

2. Infrastructure Validation with AI

Based on your workflow example, here’s how to analyze Terraform validation results:

name: Infrastructure Review

on:
  pull_request:
    paths: ['**.tf', '**.tfvars']

permissions:
  contents: read
  models: read
  pull-requests: write

jobs:
  terraform-ai-review:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Terraform Validate
      id: validate
      run: |
        terraform init
        terraform validate -json > validation.json

    - name: AI Infrastructure Analysis
      uses: actions/ai-inference@v1
      id: ai-analysis
      with:
        model: 'gpt-4o'
        system-prompt: 'You are a senior DevOps engineer reviewing Terraform configurations'
        prompt: |
          Analyze this Terraform validation output:

          $

          Provide:
          1. **Overall Assessment**: Summary of validation status
          2. **Key Findings**: Important issues or successes identified
          3. **Recommendations**: Specific actions to improve the infrastructure
          4. **Security Considerations**: Any security implications
          5. **Best Practices**: Suggestions for following AWS/Terraform best practices

          Format as clear markdown sections.

    - name: Post Analysis to PR
      if: github.event_name == 'pull_request'
      env:
        GITHUB_TOKEN: $
      run: |
        gh pr comment $ --body "
        ## 🤖 AI Infrastructure Analysis

        **Analyzed by**: $

        $

        ---
        *This analysis was generated by AI using GitHub Models. Please review recommendations carefully before implementing.*
        "

3. Automated Changelog Generation

Simplify release management with AI-generated changelogs:

name: Generate Changelog

on:
  push:
    tags: ['v*']

permissions:
  contents: write
  models: read

jobs:
  generate-changelog:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0

    - name: Get Commits Since Last Tag
      id: commits
      run: |
        LAST_TAG=$(git describe --tags --abbrev=0 HEAD^)
        COMMITS=$(git log --pretty=format:"%h %s" $LAST_TAG..HEAD)
        echo "commits<<EOF" >> $GITHUB_OUTPUT
        echo "$COMMITS" >> $GITHUB_OUTPUT
        echo "EOF" >> $GITHUB_OUTPUT

    - name: Generate Changelog with AI
      env:
        GITHUB_TOKEN: $
      run: |
        CHANGELOG=$(curl -s -X POST "https://models.github.ai/inference/chat/completions" \
          -H "Content-Type: application/json" \
          -H "Authorization: Bearer $GITHUB_TOKEN" \
          -d "{
            \"model\": \"openai/gpt-4o\",
            \"messages\": [
              {
                \"role\": \"system\",
                \"content\": \"Generate concise changelogs from git commits. Group into Features, Bug Fixes, and Improvements. Use bullet points.\"
              },
              {
                \"role\": \"user\",
                \"content\": \"Generate changelog for these commits:\n$\"
              }
            ]
          }")

        CONTENT=$(echo "$CHANGELOG" | jq -r '.choices[0].message.content')

        gh release create $ \
          --title "Release $" \
          --notes "$CONTENT"

⚖️ GitHub Models vs Claude Code: When to Choose What

After using both GitHub Models and Claude Code Action, here’s how they compare:

GitHub Models: The Function Call Approach

Best for:

• ✅ Simple analysis and classification tasks
• ✅ Text generation and summarization
• ✅ Quick decision-making workflows
• ✅ Teams wanting zero external dependencies
• ✅ Cost-sensitive projects (free tier)

Characteristics:

• Less agentic: Direct prompt → response pattern
• Simple integration: Just API calls in workflows
• Limited context: Single prompt interactions
• Fast setup: No external accounts needed

# GitHub Models pattern
- name: Simple Analysis
  run: |
    curl -X POST "https://models.github.ai/inference/chat/completions" \
      -H "Authorization: Bearer $GITHUB_TOKEN" \
      -d '{"model": "gpt-4o", "messages": [...]}'

Claude Code Action: The Agentic Assistant

Best for:

• ✅ Complex code reviews and implementations
• ✅ Multi-step reasoning and planning
• ✅ Interactive problem-solving
• ✅ Code refactoring and improvements
• ✅ Context-aware discussions

Characteristics:

• More agentic: Can use tools, implement changes, reason through problems
• Interactive: Responds to @claude mentions in PRs/issues
• Context-aware: Understands repository structure
• Requires setup: Anthropic’s API key or Claude Pro / Max subscription

# Claude Code pattern
- name: Claude Code Review
  uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: $
    mode: 'review'

Decision Matrix

Cost Comparison

🔧 Essential CLI Commands

If you want to experiment locally, here are the working CLI commands:

# Install GitHub CLI (if not installed)
brew install gh  # macOS
sudo apt install gh  # Ubuntu

# Install GitHub Models extension
gh extension install github/gh-models

# List available models
gh models list

# Test a simple prompt
gh models run openai/gpt-5 "Hello from CLI"

🚀 Getting Started: Your First AI Workflow

Week 1: Pick One Use Case

Choose the simplest automation opportunity:

• Bug report analysis
• PR summary generation
• Simple code review comments

Implementation Steps

1. Add permissions to your workflow:

   permissions:
     models: read
   

2. Copy a basic example and modify for your needs

3. Test with small prompts to understand token usage

4. Iterate and expand based on results

Pro Tips

• Start small: Begin with 1-2 sentence prompts
• Monitor usage: Check your token consumption in GitHub settings
• Add fallbacks: Handle API failures gracefully
• Validate outputs: AI responses aren’t always correct

🎯 The Bottom Line

GitHub Models excels at simple, direct AI integration where you need quick analysis or text generation within your existing workflows. It’s perfect for teams that want AI capabilities without external dependencies or complex setup.

Choose GitHub Models when you need:

• Simple analysis and classification
• Zero-setup AI integration
• Cost-effective automation
• Direct API control

Choose Claude Code when you need:

• Complex reasoning and planning
• Code implementation capabilities
• Interactive problem-solving
• Multi-step agentic behavior

The beauty of GitHub Models lies in its simplicity and accessibility. You can add AI capabilities to your workflows in minutes, not hours, and start seeing value immediately.

Start with GitHub Models for simple tasks, then graduate to Claude Code when you need more sophisticated AI assistance. Both have their place in the modern DevOps toolkit.

📚 Sources

• GitHub Models Documentation
• GitHub Models Quickstart Guide
• GitHub Marketplace Models

Have you tried GitHub Models in your workflows? What use cases are you most excited about? Share your experiments and results in the comments below.