Social Image

The Goal Isn't the Language #

The real motivation behind Quest? To push the boundaries of what's possible when you treat AI agents as full development partners, not just autocomplete tools.

The question I wanted to answer: Can we develop novel workflows that produce genuinely high-quality code at scale using AI agents? Not toy demos. Not simple CRUD apps. Real software with edge cases handled, proper test coverage, and maintainable architecture.

I needed something genuinely challenging to test these limits. A programming language is perfect for this because it can be arbitrarily complex—you start with a parser, add a runtime, build a standard library, create tooling, and suddenly you're dealing with edge cases, performance optimization, error handling, and all the messy reality of real software development.

Need proof that Quest actually works? The blog you're reading right now runs on Quest. The entire codebase—routing, templating, static file serving, everything—is written in Quest and lives on GitHub.

The Problem We're Actually Solving #

Here's what happens when developers use AI agents in an ad-hoc way:

  • Wildly inconsistent quality between sessions
  • Context evaporates when you hit token limits
  • No specs means the generated code becomes your documentation (yikes)
  • Happy path syndrome where everything works perfectly until it doesn't

We've all been there. You get Claude or another AI to generate some code, it looks great, you're feeling productive... and then you realize it doesn't handle errors, has no tests, and you can't remember why you made certain design decisions.

A New Development Workflow #

Quest uses a structured, multi-step process that treats AI agents as development partners. Every feature follows this flow:

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

1. Specifications First #

Before any code exists, we create a QEP (Quest Enhancement Proposal) that documents:

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

These live in Git alongside the code. No external tools. No context loss. Just markdown files that both humans and AI agents can read.

2. Multi-Agent Review #

Different AI agents review different aspects:

  • Spec Review catches design issues before coding starts
  • Code Review ensures implementation matches the spec
  • Test Review validates edge cases are covered

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

3. Human-in-the-Loop #

AI agents propose. Humans decide. We maintain checkpoints where:

  • Owners review specs for completeness
  • Approvers validate implementation quality
  • Testers verify all tests pass

4. Automated Quality Gates #

Nothing merges without:

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

What This Enables: A Language in Week #

With this workflow, Quest went from concept to a working language with:

  • An interactive REPL
  • Pattern matching
  • A module system
  • A production-ready web server built on Rust's Tokio runtime
  • Comprehensive standard library

Here's what Quest code looks like:

# Everything is an object (thanks Ruby!)
let x = 42
x.plus(8)    # => 50
x.times(2)   # => 84
x.str()      # => "42"

# F-strings (thanks Python!)
let name = "Alice"
let age = 30
puts(f"Hello, {name}! You're {age} years old.")

# Pattern matching (thanks Elixir!)
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

And building a web server is delightfully simple:


route.get("/page/{slug}", fun (req)
    let slug = req["params"]["slug"]
    let page = db.page.find_by_slug(db.get_db(), slug, true)
    if page == nil
        return not_found_handler(req)
    end
    
    try
        page["content_html"] = markdown.to_html(page["content"])
    catch e
        logger.error("Error converting markdown: " .. e.message())
        page["content_html"] = "<p>Error rendering content</p>"
    end
    
    return render_template("page.html", {
        page: page,
        pages: get_published_pages()
    })
end)

Why This Matters #

The 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

More importantly, it demonstrates that we can build complex software systems with AI agents when we give them the right workflows and tools.

The Real Innovation #

Quest the language is fun. It's a celebration of features I love from other languages. But Quest the process is what matters. It's a proof of concept that we can:

  • Build genuinely complex software with AI assistance
  • Maintain quality through structured workflows
  • Keep humans in control while leveraging AI capabilities
  • Scale development without sacrificing maintainability

Should You Use Quest? #

For production work? Absolutely not. It's experimental and quirky.

But should you steal the development process? Yes. The workflows, the multi-agent review approach, the structured specs—these patterns work with any language and any AI agent.

The future of software development isn't about AI replacing developers. It's about developing novel workflows where AI agents and humans collaborate effectively. Quest is one experiment in that direction.

And honestly? It's been a blast.

Want to explore more? Check out the full documentation and the GitHub repo. The complete development process is documented in QEP-000: Development Flow.