Introduction #

Quest, also known as "Vibe Quest" is a batteries-included general-purpose scripting language created as an experiment to attempt to push my personal boundaries of what is possible with agent assisted coding. One of the primary goals is to develop and improve on processes that improve the code quality of AI generated code.

Links #

If you want to skip all of the details below and jump right into quest here are the key links and repos:

Purpose #

The primary purpose from the beginning for Quest wasn't the language itself, but to build a new development process that is centered around producing high-quality code with AI agents. Not just to generate some simple toy application, but to push the boundaries of what is currently possible and to build tools and processes to harness that capability. Quest was chosen as a fun project that starts with a reasonably hard programming task in creating a new novel scripting language, but has the ability to grow through additional frameworks and libraries to arbitrary complexity.

A Novel Process #

One of the most interesting aspects of Quest isn't just what it borrows from other languages—it's how it's being built.

Quest is developed using a structured, AI-assisted workflow that solves many of the challenges of modern software development. Rather than treating AI agents as code-completion tools, we use them as full development partners in a multi-step process.

I documented this entire approach in QEP-000: Development Flow—it's worth reading if you're curious about the details. But here's the core idea:

The Problem with Ad-Hoc AI Development #

When developers give AI agents coding tasks without structure, problems emerge:

  • Quality varies wildly between sessions
  • Context loss when sessions hit token limits
  • Missing specs mean implementation becomes the documentation
  • Incomplete features that work for the happy path but fail on edge cases

Quest's Solution: Structured Multi-Step Development #

Every feature in Quest follows this flow:

Request → Spec → Review → Implement → Test → Document → Approve

1. Specifications First (QEPs - Quest Enhancement Proposals)

Before a single line of code is written, we create a QEP that documents:

  • What problem we're solving and why
  • Complete API design with examples
  • Implementation strategy
  • Test plan
  • Success criteria

These specs live in the repository alongside the code, versioned with Git. No external tools required. This means:

  • Humans and AI agents have full context
  • No dependency on external services
  • Complete history of design decisions
  • Searchable alongside code

2. Multi-Agent Review Process

Different AI agents review:

  • Spec Review - Catches design issues before coding
  • Code Review - Ensures implementation matches spec
  • Test Review - Validates edge cases are covered

This diverse perspective prevents blind spots that single-agent development misses.

3. Human-in-the-Loop Checkpoints

Humans make the critical decisions:

  • Owner reviews specs for completeness
  • Approver validates implementation quality
  • Tester verifies all tests pass

AI agents propose, humans decide.

4. Automated Quality Gates

Nothing merges without:

  • Full test suite passing
  • Documentation updated
  • All checklist items complete

Bug Tracking for AI Agents #

Quest keeps bugs in a simple directory structure that's easy for AI agents to search and reference. Every bug gets:

  • A directory in bugs/ with reproduction case
  • Root cause analysis documented in markdown
  • Status tracking (open → [FIXED])

Example structure:

bugs/
  021_return_in_top_level_script/
    description.md     # Root cause analysis
    example.q          # Minimal reproduction

When an AI agent encounters an issue, it can quickly search the bugs/ directory to see if it's a known problem. The reproduction case helps validate fixes and becomes a regression test.

This approach could integrate with external bug trackers like Jira or Linear in the future, with the detailed reproduction and analysis living in the repository where AI agents can access it.

Why This Matters #

This structured approach solves real problems:

  • Consistency - Same request, same quality result
  • Persistence - Knowledge survives session boundaries
  • Confidence - Multiple review stages catch issues
  • Completeness - Checklists ensure nothing is missed
  • Traceability - Git history preserves full context

The Result #

Overall code quality and productivity is increased. Bugs are rooted out with unit, regression and fuzz testing.

Inspiration #

Quest's syntax is a love letter to other programming languages. It draws all my favorite features from existing languages. While Quest isn't trying to revolutionize programming it a celebration of the features that make coding delightful.

Everything is an Object (Thanks, Ruby!) #

Ruby taught me that consistency is beautiful. In Quest, everything is an object, and that means everything has methods. Even numbers.

let x = 42
x.plus(8)           # => 50
x.times(2)          # => 84
x.str()             # => "42"

# Even access the method itself!
let add = 5.plus
add._doc()          # Get documentation for the plus method

Python's Greatest Hits #

Python has given us so many delightful features. Quest borrows three of my favorites:

1. The Interactive REPL #

Python's interactive shell is one of the most productive programming environments ever created. Quest's REPL tries to capture that same feel:

quest> let person = {name: "Alice", age: 30}
{"name": "Alice", "age": 30}

quest> person.keys()
["name", "age"]

quest> person.get("name")
"Alice"

The REPL is smart about multi-line input. Start a function definition or an if statement, and it knows to wait for you to finish:

quest> fun greet(name)
  .>     "Hello, " .. name
  .> end
<fun greet>

quest> greet("World")
"Hello, World"

2. F-Strings #

Python's f-strings are incredible for string formatting:

let name = "Alice"
let age = 30
let score = 95.7

puts(f"Hello, {name}! You're {age} years old.")
puts(f"Your score: {score}%")

Output:

Hello, Alice! You're 30 years old.
Your score: 95.7%

And for those times you need binary data, there are b-strings:

let data = b"\xFF\x00\x42"
data.len()        # => 3
data.get(0)       # => 255

3. Docstrings #

Python's docstrings are genius—documentation that lives with the code and is accessible at runtime:

fun fibonacci(n)
    """
    Calculate the nth Fibonacci number.

    Examples:
        fibonacci(0)  # => 0
        fibonacci(1)  # => 1
        fibonacci(5)  # => 5
    """
    if n <= 1
        return n
    end
    return fibonacci(n - 1) + fibonacci(n - 2)
end

# Access documentation interactively
puts(fibonacci._doc())

No context switching to external documentation—the help is built right in!

Lambdas and Closures (Thanks, JavaScript!) #

JavaScript showed us that functions can be lightweight and expressive. Quest's lambdas capture that spirit:

let numbers = [1, 2, 3, 4, 5]

numbers.map(fun(x) x * 2 end)           # => [2, 4, 6, 8, 10]
numbers.filter(fun(x) x > 2 end)        # => [3, 4, 5]
numbers.reduce(fun(a, b) a + b end, 0)  # => 15

# Closures work exactly as you'd expect
fun make_counter()
    let count = 0
    return fun()
        count = count + 1
        count
    end
end

let counter = make_counter()
puts(counter())  # => 1
puts(counter())  # => 2
puts(counter())  # => 3

Pattern Matching (Thanks, Elixir & Rust!) #

Pattern matching makes code read like prose:

fun describe_age(age)
    match age
    in 0 to 12
        "child"
    in 13 to 19
        "teenager"
    in 20 to 64
        "adult"
    else
        "senior"
    end
end

puts(describe_age(7))   # => "child"
puts(describe_age(15))  # => "teenager"
puts(describe_age(45))  # => "adult"
puts(describe_age(70))  # => "senior"

Clean Module System (Thanks, Go!) #

Go's import system is straightforward and explicit. Quest follows that philosophy:

use "std/encoding/json" {stringify, parse}
use "std/hash"
use "std/io"

let data = {name: "Alice", score: 100}
let json_str = stringify(data)

puts(json_str)
io.write("data.json", json_str)

let checksum = hash.sha256(json_str)
puts(f"Checksum: {checksum}")

Built with the web in mind #

Quest comes with a high-performance, production-ready web server built on Tokio, Rust's async runtime. This means you get the ease of a scripting language with the performance of compiled Rust underneath.

Basic example #

Creating a web server in Quest is incredibly simple:

use "std/web" as web
use "std/encoding/json"
use "router" as router {Get, Post}

# Route handlers
@Get(path: "/", match_type: "exact")
fun home_handler(req)
    return {
        status: web.HTTP_OK,
        headers: {"Content-Type": "text/html; charset=utf-8"},
        body: "Hello, World!"
    }
end

@Get(path: "/api/user/", match_type: "prefix")
fun user_handler(req)
    # Extract user ID from path
    let user_id = req["path"].replace("/api/user/", "")
    let data = {id: user_id, name: "Alice", status: "active"}

    return {
        status: web.HTTP_OK,
        headers: {"Content-Type": "application/json"},
        body: json.stringify(data)
    }
end

@Post(path: "/api/data", match_type: "exact")
fun post_data_handler(req)
    let body = json.parse(req["body"])
    puts("Received: " .. body.str())

    let response_data = {success: true, received: body}
    return {
        status: web.HTTP_OK,
        headers: {"Content-Type": "application/json"},
        body: json.stringify(response_data)
    }
end

# 404 handler
fun not_found_handler(req)
    return {
        status: web.HTTP_NOT_FOUND,
        headers: {"Content-Type": "text/html; charset=utf-8"},
        body: "<h1>404 Not Found</h1>"
    }
end

# Main request handler
fun handle_request(req)
    puts("[LOG] " .. req["method"] .. " " .. req["path"])
    return router.dispatch(req, not_found_handler)
end

# Run with: quest serve <filename>.q

Should I use Quest for my project? #

Certainly not. Unless you simply want to experiment with extending the language design or developing novel web frameworks in quirky ways there are a lot more mature and performant options. Quest is not production ready despite Claude's many claims.