Build Your Own AI Coding Assistant in a Weekend (Without Writing Code)

Will Schenk — Tue, 30 Dec 2025 19:08:37 +0000

Ever wonder exactly how "vibe coding" works? How tools like Cursor and Claude Code seem to understand your codebase and make edits on your behalf?

I just published a free tutorial that teaches you to build a fully functional AI coding assistant—and here's the twist: you won't write a single line of code yourself.

The agent builds itself.

What You'll Build

By the end of this tutorial, you'll have a working AI coding assistant that can:

Navigate and understand your codebase
Edit files with precision using structured diff tools
Support custom skills you define
Generate images and videos
Search the web for documentation
Spawn specialized sub-agents for focused tasks
Track API costs so you don't blow your budget
Log sessions for debugging

More importantly, you'll understand why each piece exists and how they fit together.

Why I Made This

There's a lot of fear about how AI will change intellectual work. Most arguments I see are born from fear and ignorance about what these tools can actually do.

So I made a tutorial where anyone can get hands-on experience building something smart enough to build itself.

You don't need to be an experienced software engineer. I give you the prompts—you just need a terminal and an API key.

The Core Insight: It's Just a Loop

Every AI coding assistant follows the same pattern:

1. User enters input
2. Send to the LLM
3. LLM returns tokens
   3a. Includes tool call? Execute it, go back to #2
4. Show result to user
5. Go to step 1

That's it. The "AI" part is the LLM. Everything else is plumbing.

The Harness Model

What we're building is called a harness—three layers working together:

Layer	What It Is	What It Does
Model	The LLM (Claude, GPT, Gemini)	The "brain"—understands intent, generates responses
Tools	Functions the model can invoke	The "hands"—read files, run commands, search the web
Prompts	Instructions shaping behavior	Clear directions on what you want

The model is powerful but blind—it can't see your filesystem or run code. Tools give it capabilities. Prompts tell it how to use them wisely.

Swap the model, and the same harness behaves differently. Change the prompts, and behavior changes. Add tools, and new capabilities emerge.

What Makes a Good Agent?

The model. 99% the model.

But the differences come from the harness:

Good context — Making sure it understands your problem
Good tools — Safe, predictable, well-described
Good prompts — Clear instructions that guide without over-constraining
Good observability — Logging and cost tracking
Good architecture — Context management, subagents, extensibility

The Tutorial Structure

11 progressive steps plus an epilogue:

Bootstrap — Start with a 50-line script that captures the core agent loop
File Operations — Add the ability to read and write files
Diff Tools — Precise editing with structured replacements
Skills System — User-defined extensions
Code Quality — Self-monitoring and linting
Image Generation — Multi-modal capabilities
Video Generation — Because why not
Web Search — Documentation and solutions
Subagents — Spawning specialized workers
Cost Tracking — Don't blow your budget
Session Logging — Debugging and improvement

Each step builds on the last. You paste prompts, the agent writes code, you watch it work.

Key Concepts You'll Grok

Tool Calling — Modern LLMs don't just output text. They output structured requests like "call read_file with path /src/index.ts". Your code executes that function and sends the result back. The model never actually runs anything—it just asks.

Context Window — The LLM's working memory. Every message, every tool result, every instruction competes for space in a fixed-size window (typically 128K-200K tokens). Managing context is the central challenge of agent design.

Streaming — You see AI assistants "typing"—that's not theater. It's tokens generating in real-time.

What You'll Understand After

Agents are loops. The core pattern is simple.
Tools are the interface. Good tool design is the difference between helpful and dangerous.
Context is the constraint. Everything traces back to managing finite context.
Observability isn't optional. If you can't see what happened, you can't fix it.

Requirements

A terminal (comes free with your computer)
An OpenRouter API key
Works best with Gemini 3 or Opus 4.5

Get Started

The full tutorial is here: Build Your Own Coding Agent

It's free. No signup required.

If you've been curious about how these tools work—or skeptical about whether AI can really write code—spend a weekend on this. You'll come away with concrete understanding instead of abstract opinions.

I'm Will Schenk, and I run Focus.AI where we help companies build AI systems. This tutorial came from a weekend project that turned into something worth sharing.

Forem: Will Schenk