AI-Assisted Coding: The Complete Developer's Guide to Tools, Agents, and Local Models

The way we write software is changing faster than at any point in the last two decades. In 2022, AI coding tools were novelty autocomplete engines. By 2026, they are autonomous agents capable of planning features, writing multi-file implementations, running tests, and iterating on failures — all without direct intervention. This post maps the full landscape: the agentic IDEs, the protocol that connects AI to your tools, the cloud coding assistants, and how to run everything privately on your own hardware.

The Shift: From Autocomplete to Agents

First-generation AI coding tools (2021–2023) were fundamentally glorified autocomplete. GitHub Copilot suggested the next line or function. The developer was always in the driver’s seat. The AI was a passenger offering suggestions.

Second-generation tools (2024–present) are fundamentally different. They operate on tasks, not tokens. You describe a goal — “add OAuth login to this Express app” — and the agent reads your codebase, plans a multi-step implementation, edits files, runs your test suite, observes failures, and iterates. The developer becomes an orchestrator rather than a typist.

This shift required three things to converge:

1. Frontier-quality models capable of multi-step reasoning over large codebases (Claude 3.5+, GPT-4o, Gemini 1.5+)
2. Context protocols that let models interact with tools, files, and APIs (Model Context Protocol, function calling)
3. Agentic loops — software infrastructure to run models in feedback cycles against real systems

All three arrived in 2024. The tools covered in this post are the result.

Claude Code

Claude Code is Anthropic’s official CLI-based coding agent. Unlike chat interfaces, Claude Code operates directly in your terminal with access to your filesystem, shell, and development tools. It reads your actual code, runs commands, and makes edits — without requiring you to paste snippets back and forth.

Core Capabilities

• Full filesystem access — reads, writes, and searches your project files directly
• Shell execution — runs tests, builds, linters, git commands, and arbitrary scripts
• Codebase awareness — indexes your project to understand structure before making changes
• Agentic loops — autonomously chains multiple tool calls to complete a task
• CLAUDE.md — project-specific memory that persists instructions, architecture notes, and coding conventions across sessions

Getting Started

1
2
3
4
5
6
7
8
9

# Install via npm
npm install -g @anthropic-ai/claude-code

# Launch in your project directory
cd my-project
claude

# Or give it a task directly
claude "add input validation to all API endpoints"

CLAUDE.md — Persistent Project Memory

The CLAUDE.md file is one of Claude Code’s most powerful features. Place it at the project root (or in subdirectories), and Claude Code reads it automatically at the start of every session.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# CLAUDE.md

## Project Overview
E-commerce API built with Node.js, Express, PostgreSQL.
Authentication uses JWT with refresh tokens stored in Redis.

## Architecture
- `src/routes/` — Express route handlers
- `src/services/` — Business logic layer
- `src/models/` — Sequelize ORM models
- `tests/` — Jest test suite

## Coding Conventions
- TypeScript strict mode
- Never use `any` type
- All database operations go through the service layer
- Write tests for every new endpoint

## Common Commands
- `npm test` — run full test suite
- `npm run lint` — ESLint
- `npm run migrate` — run pending DB migrations

Slash Commands

Inside a Claude Code session, slash commands provide quick access to built-in features:

Hooks — Automating Claude Code’s Lifecycle

Hooks let you run shell commands at specific points in Claude Code’s execution lifecycle — before/after tool calls, on session start, or when specific events occur. This turns Claude Code into a pipeline component.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// ~/.claude/settings.json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Running: $CLAUDE_TOOL_INPUT' >> ~/.claude/bash_log.txt"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "prettier --write $CLAUDE_TOOL_INPUT_FILE_PATH 2>/dev/null || true"
          }
        ]
      }
    ],
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "git fetch --quiet origin 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

Permissions Model

Claude Code uses a granular permission system. By default it asks before executing shell commands and before writing files. You can pre-approve specific patterns:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// ~/.claude/settings.json
{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(pytest *)",
      "Write(src/**)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push *)"
    ]
  }
}

MCP Integration

Claude Code supports MCP servers (covered in depth below), dramatically expanding what it can interact with. Any MCP server you configure becomes a tool available to Claude during a session.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// ~/.claude/settings.json (or project .claude/settings.json)
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    }
  }
}

The Agent SDK

For teams building AI-powered workflows on top of Claude, Anthropic provides the Claude Agent SDK. It enables programmatic creation of agents that can use tools, maintain conversation history, and integrate into CI/CD pipelines.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import anthropic

client = anthropic.Anthropic()

tools = [
    {
        "name": "run_tests",
        "description": "Run the project's test suite",
        "input_schema": {
            "type": "object",
            "properties": {
                "test_path": {"type": "string", "description": "Optional specific test path"}
            }
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=tools,
    messages=[
        {"role": "user", "content": "Fix the failing tests in the auth module"}
    ]
)

Google Antigravity

Google Antigravity is Google’s agentic development platform, launched publicly on November 18, 2025 alongside the release of Gemini 3 Pro. It is Google’s answer to Cursor and Claude Code, but positioned as a step beyond — a fully agentic IDE where autonomous agents are first-class citizens rather than assistants. The platform has since advanced to Antigravity 2.0, unveiled at Google I/O in May 2026, which tracks Google’s current Gemini 3.5 models.

Antigravity is a heavily modified fork of Visual Studio Code, making it immediately familiar to the 70%+ of developers already using VS Code.

Two Views

Antigravity’s distinguishing UI innovation is two complementary views:

Editor View — the familiar VS Code interface with an AI agent sidebar. Functionally similar to Cursor or Copilot Chat, but backed by Gemini 3.5 Pro as the default model.

Manager View — a control center for orchestrating multiple autonomous agents working in parallel across different tasks and workspaces. You can dispatch five agents to work on five different bugs simultaneously, review their artifacts, and merge results — all from a single interface.

Artifacts

Agents in Antigravity generate Artifacts — structured deliverables produced during task execution:

• Task plans (the agent’s implementation strategy before touching code)
• Code diffs and implementation summaries
• Browser recordings of UI interactions
• Test results and screenshots

Artifacts are reviewable before the agent proceeds. You can annotate them with inline comments, and the agent incorporates feedback without pausing its broader execution flow. This gives you oversight without micromanagement.

Browser Agents

Antigravity includes browser subagents that can launch Chrome headlessly, navigate your running application, interact with UI elements, and validate functionality. This closes the feedback loop between code changes and observed behavior — the agent can write a feature and verify it works end-to-end without human intervention.

Model Support

Antigravity primarily uses Google’s Gemini family but supports multiple providers:

• Gemini 3.5 Pro — default, general-purpose tasks
• Gemini 3.5 Flash — faster, lighter tasks
• Claude Sonnet 4.6 / Claude Opus 4.8 — available for teams preferring Anthropic models
• GPT-OSS-120B — open-source OpenAI variant

antigravity.codes

antigravity.codes is a community-run resource hub offering over 1,500 MCP server configurations, 500+ AI coding rules, and pre-built workflows specifically optimized for Antigravity, Cursor, and Windsurf. It functions as an unofficial package registry for AI IDE customizations.

The site includes:

• Turn-key MCP configurations for GitHub, GitLab, Azure DevOps, Firebase, JetBrains, and more
• Rules files that enforce coding standards (e.g., “always use TypeScript strict mode”, “prefer functional React components”)
• Workflow templates for common patterns (feature development, bug fixes, refactoring sessions)

The community project antigravity-awesome-skills extends this with 900+ agentic skills compatible with Claude Code, Antigravity, and Cursor.

Availability

Antigravity is free in public preview with generous Gemini rate limits. An enterprise tier with higher limits and private deployment options is expected. Available for Windows, macOS, and Linux.

Model Context Protocol (MCP)

The Model Context Protocol is an open standard developed by Anthropic that defines how AI models connect to external tools, data sources, and services. Before MCP, every AI tool built its own one-off integrations — a GitHub integration for Copilot, a different one for Cursor, yet another for Claude. MCP standardizes this: one server, many clients.

How MCP Works

MCP defines a client-server architecture with three communication primitives:

• Tools — functions the AI can call (e.g., create_github_issue, run_sql_query)
• Resources — data sources the AI can read (e.g., file contents, database schemas)
• Prompts — pre-built prompt templates the server exposes

AI Client (Claude Code, Cursor, Antigravity, etc.)
         │  JSON-RPC over stdio or SSE
         ▼
    MCP Server (filesystem, GitHub, database, etc.)
         │
         ▼
  External System (filesystem, GitHub API, PostgreSQL, etc.)

Communication uses JSON-RPC 2.0 over either stdio (for local processes) or Server-Sent Events (for remote servers).

Configuring MCP Servers

MCP servers are configured per-client. In Claude Code (~/.claude/settings.json), Cursor (.cursor/mcp.json), or Antigravity (antigravity.json), the format is broadly similar:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_yourtoken"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://user:pass@localhost:5432/mydb"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA..."
      }
    }
  }
}

Official Reference Servers

Anthropic maintains official reference servers at github.com/modelcontextprotocol/servers:

Popular Community MCP Servers

The MCP ecosystem has exploded. Key community servers:

Infrastructure & Cloud:

• docker-mcp — manage Docker containers, images, volumes, networks
• kubernetes-mcp — kubectl operations via natural language
• aws-s3-mcp — read/write S3 objects
• firebase-mcp — Firebase/Firestore operations (official from Google)

Databases:

• mcp-clickhouse — ClickHouse analytics queries
• mongodb-lens — MongoDB CRUD and aggregation
• mcp-neo4j — Neo4j graph database
• mcp-snowflake-server — Snowflake data warehouse
• elasticsearch-mcp-server — Elasticsearch indexing and search

Developer Productivity:

• n8n-mcp — build n8n automation workflows
• jetbrains-mcp — JetBrains IDE integration
• azure-devops-mcp — work items, pipelines, repos

Communication:

• slack-mcp — post messages, read channels
• linear-mcp — Linear issue tracking
• jira-mcp — Jira ticket management

Building a Custom MCP Server

Creating a server for your own tools takes ~50 lines of TypeScript:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
import { execSync } from "child_process";

const server = new Server(
  { name: "deploy-tools", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "deploy_to_staging",
      description: "Deploy current branch to the staging environment",
      inputSchema: {
        type: "object",
        properties: {
          branch: { type: "string", description: "Branch to deploy" }
        },
        required: ["branch"]
      }
    }
  ]
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "deploy_to_staging") {
    const branch = request.params.arguments?.branch as string;
    const output = execSync(`./scripts/deploy.sh staging ${branch}`).toString();
    return { content: [{ type: "text", text: output }] };
  }
  throw new Error("Unknown tool");
});

const transport = new StdioServerTransport();
await server.connect(transport);

MCP Security Considerations

MCP servers run as local processes with whatever permissions your user account has. Key security practices:

• Scope filesystem access — pass only the directories you want the AI to touch: server-filesystem /home/user/project not /
• Use read-only tokens — create GitHub PATs with minimum required scopes
• Audit tool definitions — understand what each tool can do before enabling it
• Be cautious with community servers — third-party servers are code running on your machine; review them
• Isolate sensitive MCP servers — use environment variables rather than hardcoding secrets in config files
• Use Streamable HTTP for remote servers — the SSE transport was deprecated in the June 2025 MCP specification; all new remote servers should use Streamable HTTP with OAuth 2.1 for authentication
• Beware prompt injection — malicious tool responses or resources can attempt to override the AI’s instructions; treat tool output with the same suspicion as user input from untrusted sources
• Principle of least privilege — follow OWASP’s “Excessive Agency” guidance: agents should have scoped, per-user tokens rather than shared high-privilege service accounts

Major AI Coding Tools

GitHub Copilot

GitHub Copilot was the tool that normalized AI code assistance. Launched in 2021, it pioneered line-by-line and function-level autocomplete inside VS Code and JetBrains. Today it has evolved significantly:

Copilot Chat — conversational AI in the IDE, can explain code, suggest refactors, and answer questions about your codebase.

Copilot Agent Mode (2025) — multi-step agentic workflows that can edit multiple files and run terminal commands, similar to Cursor Agent.

Copilot Extensions — MCP-compatible tool integrations for GitHub Actions, Datadog, Sentry, Docker, and more.

Strengths: Deep GitHub integration, broad enterprise adoption, works in VS Code and JetBrains without switching editors.

Weaknesses: Less capable agentic behavior compared to Cursor or Claude Code; heavily geared toward GitHub-hosted projects.

Cursor

Cursor is a VS Code fork that puts AI at the center of the editing experience. It became the benchmark for “AI-native IDEs” and drove the 2024 shift to agent-mode coding.

Autocomplete (Tab): Context-aware multi-line completions that account for the full file and open tabs — not just the line above.

Chat: Inline and sidebar chat with @codebase, @file, @web, and @docs context selectors. You can reference specific files, paste screenshots, and ask questions across the full codebase.

Agent Mode (Ctrl+I): Full agentic editing — the model reads relevant files, proposes a plan, edits across multiple files, and can run terminal commands. Supports checkpoint-based rollback.

Cursor Rules (.cursorrules): Project-level instructions that shape the AI’s behavior for every interaction, similar to Claude Code’s CLAUDE.md.

MCP Support: Full MCP integration as of Cursor 0.43, enabling the same ecosystem of tool servers available to Claude Code and Antigravity.

Strengths: The most polished AI-native IDE, excellent agent UX, large community with extensive .cursorrules libraries.

Weaknesses: VS Code fork divergence requires keeping up with upstream updates; can be expensive at scale.

Windsurf / Devin Desktop (Cognition)

Windsurf began as Codeium’s flagship AI IDE — a VS Code fork — and then ran through 2025’s messiest ownership saga: a collapsed ~$3B OpenAI deal, a Google DeepMind hire of its founding leadership, and finally an acquisition of the remaining product, brand, and team by Cognition (the company behind the Devin agent) in July 2025. As of June 2026 it has been folded into Cognition’s lineup and rebranded Devin Desktop, though the underlying engine and its signature features carry over. Its differentiator is the Cascade engine — a flow-based agent that maintains a persistent understanding of what has changed in your codebase session-over-session.

Cascade: Windsurf’s agentic engine tracks file edits, terminal output, and browser state as a continuous flow of observations. This gives it better contextual continuity across a long coding session compared to tools that treat each interaction as isolated. Cascade Memories persist context across sessions.

Riptide Search: A proprietary search engine that indexes codebases at scale and can scan millions of lines in seconds — a significant advantage for large monorepos where embedding-based search degrades.

Supercomplete: Windsurf’s autocomplete is multi-line and intention-aware, predicting not just the next token but the full logical completion of what you’re doing.

MCP Support: Windsurf supports MCP servers, making the same ecosystem of integrations available as in Cursor and Antigravity.

Pricing and branding are in flux under Cognition after the June 2026 Devin Desktop rebrand — verify current plans before committing.

Strengths: Competitive pricing, excellent autocomplete quality, Cascade’s session continuity.

Weaknesses: Smaller community than Cursor; fewer pre-built rule libraries.

Continue.dev

Continue is an open-source AI coding assistant that runs as an extension in VS Code or JetBrains. Unlike Cursor and Windsurf (which are full IDE forks), Continue is modular: you bring your own models.

This makes Continue the natural choice for:

• Teams that need to stay in their existing IDE
• Organizations with data privacy requirements
• Developers wanting to use local models (Ollama, LM Studio)
• Cost-conscious teams that want to use smaller models for autocomplete and larger ones for chat

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# ~/.continue/config.yaml
models:
  - name: Claude Sonnet (Chat)
    provider: anthropic
    model: claude-sonnet-4-6
    apiKey: sk-ant-...

  - name: Qwen2.5-Coder-32B (Local Chat)
    provider: ollama
    model: qwen2.5-coder:32b
    apiBase: http://localhost:11434

tabAutocompleteModel:
  name: Qwen2.5-Coder-1.5B (Autocomplete)
  provider: ollama
  model: qwen2.5-coder:1.5b
  apiBase: http://localhost:11434

embeddingsProvider:
  provider: ollama
  model: nomic-embed-text

contextProviders:
  - name: code
  - name: docs
  - name: diff
  - name: terminal
  - name: problems
  - name: folder
  - name: codebase

Strengths: Open source, model-agnostic, runs in existing IDE, excellent local model support.

Weaknesses: No built-in agent mode comparable to Cursor Agent; requires more configuration; UX less polished than commercial alternatives.

Aider

Aider is a command-line AI coding assistant that runs in your terminal and makes changes directly to your git repository. It is the preferred tool for developers who live in the terminal or who want scriptable AI coding in CI/CD pipelines.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Install
pip install aider-chat

# Launch in a project (uses Claude by default if ANTHROPIC_API_KEY is set)
cd my-project
aider

# Give it a task
aider --message "refactor the authentication module to use JWT"

# Use a specific model
aider --model claude-sonnet-4-6

# Watch mode — responds to file changes automatically
aider --watch

Aider has a sophisticated model leaderboard at aider.chat/docs/leaderboards tracking coding performance by model. As of mid-2026, Claude Opus 4.8 and Claude Sonnet 4.6 lead.

Aider with local models:

1
2
3
4
5
6
7
8

# Use Ollama backend
aider --model ollama/qwen2.5-coder:32b

# Use any OpenAI-compatible endpoint (LM Studio, llama.cpp server)
OPENAI_API_KEY=dummy aider \
  --openai-api-base http://localhost:1234/v1 \
  --openai-api-key dummy \
  --model openai/qwen2.5-coder-32b

Strengths: Terminal-native, git-integrated, scriptable, excellent with local models, transparent about what it’s changing.

Weaknesses: Terminal UX isn’t for everyone; no visual diff/merge interface.

Cline (formerly Claude Dev) and RooCode

Cline is a VS Code extension that provides a full agentic coding experience powered by any LLM with tool-use capability. It started as “Claude Dev” before being rebranded. Unlike Cursor (a fork), it’s a pure extension.

RooCode (formerly Roo Cline) is an actively developed fork of Cline with additional features including Boomerang Task Management (native multi-step task planning that removes the need for external task-management MCP servers), Architect/Code/Debug/Custom agent modes, and better local model support.

Both support the full MCP ecosystem and can be pointed at any OpenAI-compatible API endpoint, making them good choices for local model experimentation.

Amazon Q Developer

Amazon Q Developer (formerly CodeWhisperer) is Amazon’s AI coding assistant, deeply integrated into AWS services. It supports VS Code, JetBrains, and the AWS Console.

Its strongest differentiator is security scanning — it can identify vulnerabilities in code and suggest fixes using AWS vulnerability knowledge. For AWS-heavy shops it also understands IAM policies, CloudFormation templates, and CDK constructs at a level other tools don’t match.

Tabnine

Tabnine is a veteran of the AI coding space, predating Copilot. Its current positioning emphasizes enterprise privacy: the ability to run the AI model entirely inside your VPC or on-premise. For organizations that cannot send code to third-party APIs, Tabnine’s on-premise option is a meaningful differentiator.

It also offers personalization — fine-tuning the model on your organization’s codebase so suggestions align with your patterns, naming conventions, and architecture.

JetBrains AI Assistant

JetBrains AI Assistant is natively integrated into the entire JetBrains family (IntelliJ, PyCharm, GoLand, WebStorm, etc.). Its strength is deep IDE integration — it understands refactoring intentions, type systems, and project structure at a level that VS Code extensions can’t quite match for JetBrains users.

Sourcegraph Cody and Amp

Sourcegraph Cody is built on Sourcegraph’s decade of code intelligence infrastructure — deep codebase indexing, cross-repo understanding, and historical code evolution awareness. For large enterprise monorepos, this context layer is a genuine differentiator over tools that rely solely on embeddings.

Amp (launched 2025) is Sourcegraph’s agentic layer on top of Cody: it plans multi-file changes, writes tests, generates documentation, and performs large-scale refactoring using Sourcegraph’s search as its knowledge base. It is currently in early access with credit-based pricing.

Best for: Teams with large, complex monorepos where understanding cross-repo dependencies and historical patterns matters.

Running Models Locally

The case for local AI coding has become compelling:

• Privacy — code never leaves your machine; essential for proprietary codebases
• Cost — eliminate per-token API costs for high-volume use cases
• Latency — fast models on capable hardware can match or beat API round-trip times
• Offline — work without internet access
• Customization — fine-tune models on your own codebase

Best Local Models for Coding (2026)

Mistral Codestral 25.01 deserves special mention for autocomplete use cases: it achieves 95.3% on Fill-in-the-Middle (FIM) benchmarks and supports a 256K context window — making it exceptional for completing code in the middle of existing functions. Its 22B size and ~14GB Q4_K_M footprint fit a single RTX 3090/4090.

Recommendation: Start with qwen2.5-coder:7b for all-around local use. Upgrade to qwen2.5-coder:32b if you have a 24GB GPU. Use qwen2.5-coder:1.5b or codestral:22b dedicated to autocomplete.

Ollama

Ollama is the simplest way to run LLMs locally. It manages model downloads, GGUF quantization selection, GPU acceleration, and serves a local HTTP API compatible with the OpenAI standard.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Install (macOS/Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Install on Linux manually
sudo systemctl enable --now ollama

# Pull coding models
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b       # Needs ~20GB VRAM
ollama pull qwen2.5-coder:1.5b      # For autocomplete
ollama pull deepseek-coder-v2:lite  # MoE, efficient

# Run interactively
ollama run qwen2.5-coder:7b

# List installed models
ollama list

# Check running models
ollama ps

Ollama REST API (compatible with OpenAI SDK):

1
2
3
4
5
6
7

# Chat completion
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder:7b",
    "messages": [{"role": "user", "content": "Write a Python binary search"}]
  }'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Use with the OpenAI Python SDK
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="qwen2.5-coder:7b",
    messages=[{"role": "user", "content": "Explain this function:\n\n```python\n...```"}]
)
print(response.choices[0].message.content)

Remote Ollama server:

1
2
3
4
5
6
7
8

# On the server, expose Ollama to network
OLLAMA_HOST=0.0.0.0 ollama serve

# Or set permanently in the service
sudo systemctl edit ollama
# Add:
# [Service]
# Environment="OLLAMA_HOST=0.0.0.0"

LM Studio

LM Studio is a GUI application for discovering, downloading, and running local models. It provides a polished interface for non-technical users and serves a local OpenAI-compatible API.

Key features:

• Visual model browser — search Hugging Face models filtered by size, quantization, and available VRAM
• Dual inference engines: llama.cpp (cross-platform CPU/GPU) and MLX (Apple Silicon native)
• OpenAI-compatible server at localhost:1234/v1
• Headless daemon mode via lms CLI
• Responses API (LM Studio 0.3.29+) — stateful, multi-turn interactions with built-in tool use and MCP server support

1
2
3
4
5

# LM Studio CLI (headless mode)
lms server start            # Start the API server
lms load qwen2.5-coder-7b   # Load a model
lms status                  # Check running models
lms server stop

Connecting VS Code Continue.dev to LM Studio:

1
2
3
4
5
6

# ~/.continue/config.yaml
models:
  - name: LM Studio (Local)
    provider: lmstudio
    model: qwen2.5-coder-7b-instruct
    apiBase: http://localhost:1234/v1

Jan.ai

Jan.ai is a free, open-source desktop application for running local models with a privacy-first philosophy. Unlike LM Studio, Jan is fully open-source (MIT licensed) and stores all data locally. It runs a local API server compatible with the OpenAI standard and can also connect to cloud APIs (OpenAI, Anthropic, Groq) from the same interface — useful for switching between local and cloud models without changing tooling.

Download from jan.ai. The local server runs on localhost:1337/v1 by default.

llama.cpp

llama.cpp is the foundational C++ inference engine that powers Ollama, LM Studio, and dozens of other tools. For maximum control — custom quantization, specific hardware tuning, server deployment — using llama.cpp directly is the right approach.

Installation:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

# CPU only
cmake -B build && cmake --build build --config Release -j $(nproc)

# CUDA (NVIDIA GPU)
cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release -j $(nproc)

# Metal (Apple Silicon)
cmake -B build -DGGML_METAL=ON && cmake --build build --config Release -j $(nproc)

GGUF Quantization Levels:

Running with GPU offloading:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Full GPU offload (all layers to VRAM)
./build/bin/llama-cli \
  -m models/qwen2.5-coder-7b-Q4_K_M.gguf \
  --n-gpu-layers 99 \
  -p "Write a quicksort in Python"

# Partial offload (split between GPU and CPU RAM)
./build/bin/llama-cli \
  -m models/qwen2.5-coder-32b-Q4_K_M.gguf \
  --n-gpu-layers 40 \
  -p "Explain this code..."

Server mode (OpenAI-compatible API):

1
2
3
4
5
6
7
8

./build/bin/llama-server \
  -m models/qwen2.5-coder-7b-Q4_K_M.gguf \
  --n-gpu-layers 99 \
  --host 0.0.0.0 \
  --port 8080 \
  --ctx-size 32768 \
  --n-predict 2048 \
  --parallel 4              # Concurrent requests

Hardware Requirements

VRAM requirements for common model sizes (Q4_K_M):

Consumer GPU comparison for 7B model (tokens/second at Q4_K_M):

Apple Silicon (MLX framework): Apple Silicon uses unified memory shared between CPU and GPU. A MacBook Pro M3 Max with 96GB RAM can run Qwen2.5-Coder-32B comfortably with about 60–90 tok/s — comparable to an RTX 4090 — while consuming a fraction of the power (~30W vs ~350W).

CPU-only inference: Modern CPUs can run 7B models at 5–15 tokens/second using llama.cpp, which is workable for batch processing but feels slow for interactive use. A high-core-count workstation (Threadripper, EPYC) with AVX-512 support reaches 30–50 tok/s for 7B models.

Connecting Local Models to Aider

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Ollama backend
export OLLAMA_API_BASE=http://localhost:11434
aider --model ollama/qwen2.5-coder:32b

# Per-project config (.aider.conf.yml)
cat > .aider.conf.yml << 'EOF'
model: ollama/qwen2.5-coder:32b
ollama-api-base: http://localhost:11434
context-window: 32768
max-tokens: 4096
EOF

Model performance in Aider (from aider.chat leaderboard):

Using Local Models with Claude Code via litellm

Claude Code itself requires the Anthropic API and cannot directly call a local Ollama instance. However, litellm acts as a proxy that accepts Anthropic-format requests and routes them to any backend — including Ollama:

1
2
3
4
5
6
7
8

# Install litellm
pip install litellm

# Start a proxy routing Anthropic-format requests to Ollama
litellm --model ollama/qwen2.5-coder:32b --port 8000

# Point Claude Code at the proxy
ANTHROPIC_BASE_URL=http://localhost:8000 claude

This lets Claude Code’s full feature set (file editing, hooks, MCP) work with a completely local model — useful for air-gapped environments or proprietary code that cannot leave your machine.

Choosing the Right Tool

There is no single “best” AI coding tool. The right choice depends on your context:

Stacking Tools

Many developers use multiple tools simultaneously:

• Cursor for day-to-day editing + autocomplete
• Claude Code via terminal for complex multi-file agentic tasks
• Ollama with Continue.dev autocomplete for fast, offline tab completion
• Aider in CI/CD pipelines for automated code changes

This is entirely reasonable — each tool has different strengths, and they complement rather than compete.

The Future: Toward Autonomous Engineering

The trajectory is clear. AI coding tools are moving from:

• Suggestions → Actions
• Files → Repositories
• Single sessions → Persistent agents with memory
• Single models → Multi-agent teams

Features already in production at Google Antigravity and advanced Claude Code deployments — autonomous browser testing, multi-agent parallel execution, artifact-based oversight — will be table stakes across the industry within 12–18 months.

The skill that will matter isn’t typing faster or knowing more syntax. It’s directing agents effectively: writing precise task descriptions, designing good CLAUDE.md and .cursorrules files, knowing when to review agent artifacts, and building MCP servers that connect AI to the systems that matter in your stack.

The developers who thrive will be those who learn to orchestrate intelligently rather than resist the shift.

Sources

• Model Context Protocol — specification and documentation
• Official MCP reference servers
• Anthropic — Claude Code documentation
• Google Antigravity
• GitHub Copilot
• Cursor
• Cognition — acquisition of Windsurf
• Continue.dev documentation
• Aider — LLM coding leaderboards
• Ollama
• LM Studio
• llama.cpp
• Qwen2.5-Coder

For a focused deep-dive on running models locally — including benchmark data, hardware comparisons, and detailed Ollama/LM Studio/llama.cpp configuration — see the companion post: Local LLM Inference for Coding: The Complete Guide.