Quest: Epic CLI tool (Learn Code by Actually Building)

Source: Dev.to

What I Built

I built Quest – a CLI tool that teaches you code by making you actually write code, not just read about it.

I used to work in big tech where most of my responsibilities were maintaining repos and building mini‑features. I didn’t get a chance for 0‑to‑1 development, so last summer I started messing around with personal projects on the side. The learning curve is real: I spent most of my time asking GPT, reading docs, and doing tutorials.

I kept thinking: why can’t I just learn this stuff while I code? Like, inside my IDE, while I’m actually building?

That’s Quest. You pick a project (or have one generated for you), and it walks you through building it step‑by‑step — with automated checks for your code and AI hints when you’re stuck. No browser tabs, no tutorial rabbit holes. Just your editor and your terminal.

A typical session

quest begin       →  Pick a quest (templates or AI‑generated)
quest next        →  See your current task
                    →  Write your code
quest check       →  Auto‑validate your implementation
quest check -a    →  AI code review with inline comments
quest explain     →  Get hints (they get more direct each time)
quest complete    →  Move on
quest summary     →  See where you’re at

The Loop

This is the core workflow. It’s dead simple on purpose:

Quest Templates

There are 7 built‑in templates ranging from 3‑task quickies to 20‑task deep dives:

Or you can skip templates entirely. Describe what you want to build, pick a difficulty, and Copilot CLI generates a custom quest plan: chapters, tasks, validation rules, everything.

Demo

Repo:

go install github.com/jovanpet/quest@latest

Starting a quest

  🧭 Quest

  Choose your path:
  > 🗡️  Pick a Legendary Path
    🔨 Forge Your Own Quest
    🎲 Seek a Mystery Quest

Checking your work

🔍 Checking Task 1: Create a Hello World endpoint

✓ File exists                    main.go found
✓ Contains HTTP server code    http.HandleFunc detected

🎉 All 2 checks passed!

→ Next step: quest complete

AI code review with quest check -a

The -a flag sends your code through Copilot CLI and injects inline comments right into your source files:

// ✓ GOOD: Correct imports for HTTP server functionality
import (
    "fmt"
    "net/http"
)

func main() {
    // TODO: What content type should the client expect from a JSON endpoint?
    handler := func(w http.ResponseWriter, r *http.Request) {
        // HINT: Plain text isn't structured JSON — what Go package helps encode structs?
        fmt.Fprint(w, "Hello, World!")
    // ✓ GOOD: Handler properly uses ResponseWriter to send response
    }
}

Progressive hints with quest explain

The hint system adapts based on how many attempts you’ve made:

Attempt 1 → Minimal hints ("Consider what happens if input is empty")
Attempt 2 → More specific ("Look into http.Error for error responses")
Attempt 3 → Direct code (partial code examples, since you’re clearly stuck)

My Experience with GitHub Copilot CLI

Copilot CLI was a huge help when refactoring code, especially when I needed to add a field and update all the templates. It powers three core features that would have been a pain to build otherwise.

Hints that actually know your code

When you run quest explain, Quest grabs your current task and pipes it to Copilot CLI. The response is structured comments tied to specific lines in your code.

A code reviewer that knows your assignment

The automated checks (quest check) handle the basics—does the file exist? Does it contain the right patterns? Adding the -a flag lets Copilot CLI do the real review. It reads your actual code and writes comments like:

• ✓ GOOD: Using http.HandleFunc correctly
• ✗ ERROR: Missing error handling on ListenAndServe
• ⚠ WARNING: Consider adding Content‑Type header

These comments are injected directly into your source files, right above the relevant lines.

Generating entire quest plans

Instead of picking a template, you describe what you want (e.g., “I want to build a princess‑fairy scheduler worker”), choose a difficulty, and Copilot CLI generates a full teaching plan in JSON. I even created an go‑isekai‑server template where you finish quests like player‑skill endpoints.

End of submission.

# Read Me

The big realization was that Copilot CLI isn't just an autocomplete tool; it's basically a programmable AI interface. I can pipe structured prompts to it and get structured output back. No API keys, no cloud hosting, no billing dashboards—just a binary that takes **stdin** and returns useful output.