Skip to main content
Quest Mode is Qoder’s autonomous coding feature, enabling agents to complete development tasks end-to-end. Simply describe your goal, and Quest will autonomously clarify requirements, plan solutions, execute code, and verify results — with minimal human intervention. Core Philosophy: Define the goal. Review the result.

​
Core features

Autonomous coding

Leading models, requirement alignment, long-running capability, quality assurance — agents deliver end-to-end production-ready results

Self-evolution

Remembers your coding style and project patterns, continuously learns new techniques, gets better over time

Multi-scenario

Intent recognition with auto-routing: Spec-driven development for traceable results, idea-to-product for 0-1 websites and prototypes

Long-running & parallel

Local + Worktree + Remote parallel execution for hours, auto-recovery from interruptions, elastic Sandbox for massive concurrency

Skills extension

Install Skills to your project to extend capabilities, with multiple built-in Skill commands ready to use

​
Switch to Quest Mode

Qoder offers two working modes:
  • Editor Mode: Real-time collaborative coding, conversational
  • Quest Mode: Task delegation, autonomous execution, hands-off delivery
How to switch: Click the Editor / Quest toggle button in the top-left corner
Under Qoder Settings > Quest Mode, you can configure Quest Mode Layout to choose which mode opens by default with each project.

​
Create a task

Click the New Quest button at the top of the task list on the left.

​
Choose a scenario

Quest offers three scenarios — choose based on your needs:
ScenarioUse caseQuest behavior
Code with SpecComplex features, refactoring, strict quality controlAligns on scope first, designs implementation and acceptance criteria, then executes
Prototype DemosQuick idea validation, frontend prototypes, creative experimentsStart from an idea, Quest turns it into a working prototype
Create ToolsRapidly build automation toolsDescribe the tool you need, Quest creates a runnable automation tool
Scenario selection rules:
  • No selection: Quest automatically determines the best approach
  • Choose Code with Spec: Will always generate a Spec document
  • Choose Prototype Demos / Create Tools: Completely skips Spec for fast execution
Once a task starts, you cannot switch scenarios. Choose before you begin.

​
Code with Spec

Use cases: Feature development, bug fixes, code refactoring; clear technical plans and acceptance criteria needed; team collaboration with documentation. Workflow:
1

Requirement clarification

After inputting your task, Quest may ask clarifying questions (in multiple-choice format):
  • Recommend: Let Quest automatically select default answers
  • Continue: Manually select and continue
  • Skip: Skip questions and proceed with the conversation
2

Generate Spec

Quest generates a structured Spec document:
  • Requirement description
  • Design plan
  • Task breakdown
  • Acceptance criteria
The Spec is displayed in the Spec Tab in the output area, with streaming output and download support.
3

Review Spec

  • View the complete document in the Spec Tab on the right
  • Modify Spec through conversation (can adjust anytime before clicking Run)
  • Click Run Spec when satisfied to begin execution
4

Execute & monitor

  • To-do List: Real-time task progress in the conversation area
  • Changed Files: View code changes in the output area
  • Add requirements mid-task: Send new requirements in the input box anytime — Quest adjusts the plan
5

Review results

After execution completes:
  • Accept (Local): Apply all changes to the workspace
  • Reject (Local): Discard all changes
  • Apply (Worktree): Merge to main branch
  • Create PR (Remote): Create a Pull Request

​
Prototype Demos

Use cases: Quickly create website or app prototypes; validate product ideas; no complex technical documentation needed. Workflow:
1

Describe your idea

Directly describe the website/prototype you want:
Example:
"Create a travel blog website with homepage, article list, and detail pages,
using modern design style with responsive layout"

"Build a todo app supporting add, delete, and mark complete,
with card-based design and priority labels"
2

Automatic execution

  • Quest automatically selects tech stack (common web frameworks)
  • No Spec needed, writes code directly
  • Automatically runs preview after code completion
3

Live preview

  • Output area automatically opens Preview Tab
  • View running results in real time
  • If page errors occur, Quest automatically checks and fixes
4

Iterative refinement

Continue the conversation to adjust:
"Change the main color to blue"
"Add a search box"
"Optimize mobile display"

​
Create Tools

Use cases: Rapidly build automation tools, CLI scripts, data processing pipelines, etc. Workflow:
1

Describe your needs

Directly describe the tool you want:
"Create a batch image compression tool supporting PNG and JPEG formats"
"Build a CSV data cleaning script with auto dedup and formatting"
2

Automatic execution

  • Quest automatically selects the right tech stack
  • No Spec needed, writes code directly
  • Automatically runs validation after completion
3

Iterative refinement

Continue the conversation to adjust features or add new capabilities until satisfied.

​
Choose an execution environment

Quest supports three execution environments — choose based on task characteristics:

​
Local

  • Features: Modifies the main workspace directly, with zero startup cost
  • Best for: Simple tasks, quick validation
  • Multi-task support: Supports multiple parallel Local tasks

​
Worktree

  • Features: Creates a hidden workspace in the background, keeps the main branch clean
  • Best for: Medium complexity tasks, multi-task parallel execution
  • Advantages: Unlimited Apply iterations

​
Remote

  • Features: Remote container execution, local machine can shut down
  • Best for: Complex long-running tasks, resource-intensive jobs
  • Dependency: Requires a configured Git repository (currently supports GitHub)
  • Multi-task support: Unlimited parallel execution
Default environment:
  • With Git repository → All three environments supported
  • Without a Git repository → Local only
All execution environments support multi-task parallel execution.

​
Pause/resume task

  • While the task is executing, click the Pause button
  • After pausing, click Resume to continue execution

​
Add requirements

During execution, send new requirements directly in the input box: 
"Add a user login feature"
"Optimize performance"
Quest will adjust the plan and continue working.

​
Edit sent messages

This feature is available in all modes except Experts Mode.
You can edit a previously sent message and resubmit it directly in the conversation. When a prompt isn’t precise enough, context needs adjusting, or you want to switch models for a different response, there’s no need to start a new conversation — just edit the original message. In edit mode, you can:
  • Modify the prompt: Rewrite or refine your text input
  • Modify attached context: Add, remove, or replace attached files and code snippets
  • Switch model or mode: Change to a different model or chat mode before resubmitting
To edit, click on a previously sent message bubble. Make your changes, then resubmit. Qoder will regenerate the response based on the updated content.
Workspace files will roll back: When you resubmit an edited message, all code and files in the workspace roll back to the state before that conversation turn. All file changes from that turn onward (including the edited turn) are discarded. For example, if you modified code in turn 3, then go back to edit and resubmit turn 2, all file changes from turns 2 and 3 will be reverted — the workspace returns to the state after turn 1. You can view the rollback results in Diff View.Context compression and one-click prompt optimization are not available in edit mode — adjust prompts manually.

​
Delete task

  • Right-click the task or hover to show the menu
  • Click Delete and confirm

​
Interface layout

Quest Mode uses a three-column layout: the task list on the left, the conversation area in the center, and the output area on the right.

​
Task list

  • New Quest: Create a new task
  • Task status:
    • Running: Executing
    • Action Required: Waiting for user action
    • Ready: Completed, can continue conversation
    • Error: Execution error
  • Tasks sorted by last interaction time

​
Conversation area

  • Displays conversation history
  • To-do List updates in real time (during execution)
  • The input box’s bottom can compress context to optimize prompts
  • Use @ in the input box to mention files, folders, code symbols, or other context — see Context for details
  • Click the microphone icon on the right side of the input box to use voice input

​
Output area

  • Spec Tab: View/download Spec document (Code with Spec scenario)
  • Changed Files Tab: View code changes, Accept/Reject
  • Preview Tab: Real-time preview of running results (Prototype Demos / Create Tools scenario)

​
Extended capabilities

​
Built-in Skills

Extend Quest’s capabilities through Skills — install Skills to {project}/.qoder/skills to use them. Quest also includes several built-in Skills you can invoke directly in the conversation:
  • /create-skill-ui: Create interactive HTML Widget interfaces for Skills
  • /vercel-deploy: Deploy web projects to Vercel via automated workflow
  • /create-skill: Scaffold a new Skill
  • /create-subagent: Scaffold a new custom agent
  • /generate-structured-prd: Generate a structured PRD document

​
Skill UI

Skill UI lets agents render interactive HTML components during execution — forms, charts, config panels, and more. The generated components are embedded directly in the conversation flow, so you can interact without leaving the chat. The first time you use a Skill UI, the agent needs to create the interface for that Skill. In the Quest Mode conversation, use the /create-skill-ui command. The agent will create an HTML Widget interface for the specified Skill, which you can preview and iterate on in real time before saving as a template file.

​
Vercel Deploy

/vercel-deploy is a one-click deployment capability in Quest Mode. It automates the entire workflow of deploying your web project to Vercel — from CLI setup and OAuth login to building and production deployment. Use the /vercel-deploy command in the Quest Mode conversation, and Qoder will automatically start the deployment workflow. On the first deployment, Qoder will guide you through Vercel OAuth login. Follow the prompts to complete account linking in your browser. Once authorized, Qoder will automatically build your project and deploy it to Vercel’s production environment. After a successful deployment, you’ll receive a live URL.
  • Vercel account required: Make sure you have a Vercel account before deploying. You can create one during the authorization flow if you don’t have one yet.
  • Project must be a buildable web app: Vercel supports Next.js, React, Vue, Svelte, and other major frameworks. If the project lacks a valid build configuration, deployment may fail. Verify that your project builds successfully locally before deploying.

​
Supabase integration

Supabase is an open-source Firebase alternative that provides PostgreSQL databases, user authentication, file storage, and real-time data sync. Quest Mode supports authorizing and connecting to Supabase projects directly, so you can handle frontend development and backend data management within the IDE — no switching between browser and editor. You can connect multiple Supabase projects simultaneously and preview database table schemas (Schema) directly in the IDE to stay on top of your backend data model. Core features:
  • Multi-project connections: Authorize and connect to multiple Supabase projects for quick switching between environments (development, testing, production) or different services.
  • Database schema preview: View database table structures of connected projects directly in the IDE — including table names, fields, types, and relationships — without opening the Supabase Dashboard.
  • Enhanced database capabilities: AI agents are aware of your database structure and can automatically generate table creation statements, data schemas, and query logic based on task requirements, ensuring frontend-backend data model consistency.
  • One-click authorization: Securely connect to Supabase through the OAuth flow — no need to manually configure API Keys or connection strings.
Supported Supabase services: After connecting a Supabase project, you can use the following services in Quest Mode:
  • Database (PostgreSQL) — Full SQL support for storing and querying application data. AI can automatically generate the tables and data schemas you need. See Supabase Database docs.
  • Authentication — Securely manage user registration, login, and access control. Supports multiple auth methods including email/password and OAuth providers like Google and GitHub. See Supabase Auth docs.
  • Storage — Upload and manage images and other files through Supabase Storage, suitable for user avatars, file uploads, and static media resources. See Supabase Storage docs.
  • Realtime — Push data changes to your application in real time, supporting live chat, dynamic feeds, collaborative dashboards, and more. See Supabase Realtime docs.
How to use: When building a project in Quest Mode, if the AI determines a Supabase connection is needed, it will prompt you in the chat panel. You can also connect proactively:
1

Prepare your Supabase project

Go to Supabase to register an account and create an organization and project.
2

Authorize

In Quest Mode, click the Supabase tab at the top of the tool panel. Click the Authorize button, follow the prompts to complete the OAuth flow, select your Supabase organization, and confirm.
3

Connect a project

After authorization, the panel displays your organizations and projects. Find the target project and click Connect to link it to the current Quest project.
4

Start building

Once connected, you can preview database table schemas directly in the Supabase panel, and the AI will use this schema information to assist your development.
Qoder projects can only connect to active Supabase projects. To switch organizations, click the toggle button next to the organization name.
Use cases:
  • Full-stack app rapid scaffolding: Describe your application requirements in Quest Mode, and the AI automatically generates the frontend UI and configures the Supabase backend — including database tables, authentication flows, and storage strategies.
  • Data model design and validation: Use the in-IDE schema preview to check whether AI-generated data models meet your expectations in real time, and adjust before continuing development.
  • Multi-environment management: Connect to both development and production Supabase projects simultaneously to easily view and compare data structures across environments.
AI-generated database operations (such as creating tables or modifying schemas) take effect directly on the connected Supabase project. For production environments, confirm operations carefully before executing.
  • Authorization security: The authorization process uses OAuth — Qoder does not store your Supabase password. Authorize only the organizations and projects you need, following the principle of least privilege.
  • Network dependency: Supabase integration requires a network connection to access Supabase cloud services. Ensure your network environment is working properly.

​
Billing

​
Restrictions

All users need Credits to use Quest:
  • Ultra / Pro+ users: Higher monthly Credits allowance included in subscription
  • Pro users: Monthly Credits allowance included; cannot continue when Credits run out
  • Free users: Limited free Credits; purchase additional Credits to continue using Quest

​
When Credits run out

  • Cannot start new tasks
  • If Credits run out during task execution:
    • Task will terminate
    • Upgrade prompt will be displayed

​
Best practices

​
Write good task descriptions

The clearer your task description, the better Quest performs. Avoid vague instructions — specify concrete goals, tech stack, and acceptance criteria: 
❌ "Optimize code"
✅ "Refactor UserService, split into smaller functions, add unit tests"

❌ "Make a website"
✅ "Create a travel blog with homepage, article list, detail pages, using Next.js"
Use @ to reference relevant files or code snippets so Quest better understands your project context.

​
Pick the right scenario and environment

Scenario determines how Quest works: choose Code with Spec for complex features to ensure a clear plan, choose Prototype Demos or Create Tools to skip Spec and execute directly, or leave it unselected and let Quest decide automatically. Environment determines where Quest runs: use Local for quick fixes, Worktree for isolated feature development, and Remote for complex long-running tasks.

​
Iterate effectively

Let Quest complete a baseline version first, then continue the conversation to refine. For complex tasks, choose Code with Spec and adjust the Spec through conversation rather than manual editing. Quest supports unlimited iterations until you’re satisfied.