Tutorials: Run and Use Open-Source Coding Models

How our tutorials work

Every CoderBaba tutorial is written to be followed from start to finish without guesswork. Each one includes:

What you will build, stated up front, so you know whether it's the right tutorial
Prerequisites: the operating system, hardware and software versions it was tested with
Copy-and-paste commands, in order, with expected output where it helps
Checkpoints to confirm each step worked before you move on
Troubleshooting for the problems people actually hit

If a step fails, the troubleshooting section below covers the most common causes across all our tutorials.

A learning path

If you are new to open coding models, follow these in order.

Level 1: Your first local model

Install Ollama and chat with a coding model in your terminal. You'll learn how models are downloaded, how quantization affects size and how to pick a model that fits your RAM. Start with How to Run an Open-Source Coding Model Locally with Ollama.

Level 2: Connect your editor

Point an editor extension at your local model for autocomplete and chat. The key ideas are the OpenAI-compatible API that Ollama exposes at http://localhost:11434/v1 and using a small model for autocomplete and a larger one for chat.

Level 3: Your first agent

Run an open-source agent, such as Aider, Cline or OpenHands, on a real task in a real repository. You'll learn how agents read files, propose edits and run tests, and why reviewing every diff matters.

Level 4: Parallel agents

Use git worktrees to give several agents their own isolated workspaces and run them side by side. Our Conductor alternative guide walks through the full setup.

Level 5: Serve a model for your team

Move from a laptop to a GPU server with vLLM or SGLang so your whole team can share one fast, private endpoint.

Prerequisites for most tutorials

A terminal you are comfortable with. macOS Terminal or iTerm2, Windows Terminal with WSL2, or any Linux shell.

Git. Agents work best in git repositories, and every tutorial assumes your code is committed before an agent touches it.

Enough memory. For the beginner tutorials, 8 GB of RAM runs a small model and 16 GB is comfortable for a 7B model. A dedicated GPU or Apple Silicon makes everything much faster, but isn't required to start.

Disk space. Model files range from about 1 GB for small models to tens of gigabytes for large ones. Keep 20 GB or more free.

Troubleshooting common problems

"Out of memory" or the system freezes

The model plus its context doesn't fit in your RAM or VRAM. Try, in order: a smaller model, such as 7B instead of 14B, a more aggressive quantization, a shorter context window, or closing other memory-hungry apps. On Macs, unified memory is shared with the system, so leave several gigabytes free.

Generation is very slow

You are probably running on CPU, or the model is partly offloaded from the GPU to system RAM. Check that your GPU drivers are installed and that the model fits entirely in VRAM. On Apple Silicon, Ollama uses the GPU automatically.

"Model not found"

Model names and tags must match exactly, for example qwen2.5-coder:7b rather than qwen2.5-coder-7b. List what you have downloaded with ollama list.

The editor extension can't connect

Make sure the local server is running (ollama serve or the Ollama app) and that the extension points to http://localhost:11434, or the /v1 path for OpenAI-compatible settings. Firewalls and VPNs sometimes block localhost ports.

The model ignores files or forgets earlier instructions

The prompt exceeded the context window and older content was cut off. Use a model with a longer context, include fewer files or start a fresh session for each task.

The agent makes the same mistake repeatedly

Smaller models struggle with long, multi-step tasks. Break the task into smaller steps, give the agent a failing test to aim for or switch to a model trained for agentic work, such as Devstral or Qwen3-Coder.

Safety habits for agent tutorials

Commit before you start, so you can always git reset or git stash an agent's changes.
Work on a branch or worktree, never directly on main.
Read diffs before accepting, especially for changes to configuration, dependencies or security-sensitive code.
Be careful with auto-approve. Letting an agent run any command without confirmation is convenient but risky outside a sandbox.

All tutorials

Every post tagged #tutorial is listed above, newest first. For background on why each step works, see our guides. For running models on your own hardware specifically, see #local-ai.

How to get the most out of a tutorial

Read it through once before typing anything. Knowing where you're headed makes the individual steps easier to follow and errors easier to spot.
Match the versions. Each tutorial lists the versions we tested. If yours are newer, most steps still work, but flags and menus sometimes move.
Stop at every checkpoint. If a checkpoint doesn't match what you see, fix that first. Problems compound when you push on.
Use a scratch project. Try agents and new configurations on a throwaway repository before pointing them at real work.
Write down what you changed. A short note of the settings you used makes it easy to reproduce your setup on another machine or explain it to a teammate.
Expect to adapt. Your hardware, operating system and codebase are different from ours. Treat the tutorial's model choices and settings as a starting point, then tune them.

Frequently asked questions

Do the tutorials work on Windows?

Most do. Ollama runs natively on Windows, and Git for Windows covers the git steps. For tutorials that use Unix shell commands, we recommend WSL2, which gives you a full Linux environment and the most reliable experience with agents and GPU drivers.

I don't have a GPU. Can I still follow along?

Yes. The beginner tutorials work on CPU with small models (1.5B to 3B parameters). Generation will be slower, but it's fine for learning the workflow. When you're ready for larger models, an Apple Silicon Mac or a single consumer GPU makes a dramatic difference.