What an AI Coding Agent Is (and How It Differs from a Chatbot)

In short

A chatbot (a regular ChatGPT-style chat) answers you with text. You ask, it writes advice or a snippet of code. What happens to that text next is your problem: copy it, paste it, run it, check it.

An AI coding agent (Claude Code, Cursor, Copilot via AGENTS.md) is a model with hands. It has tools: read files in your project, search the codebase, edit files, run terminal commands, execute tests. It doesn't just advise — it acts in a loop: take a step, look at the result, take the next one.

A simple analogy. A chatbot is a consultant on the phone: it will explain how to change a tire. An agent is the mechanic who picks up the wrench and changes the tire, checking their work as they go.

Why this matters

Hands come at a price. Since the agent can change files and run commands on its own, it can also break things on its own: overwrite someone else's code, delete something you needed, run a dangerous command, "fix one thing and break its neighbor." The worst a chatbot can do is give bad advice — you're under no obligation to follow it. An agent executes on its own.

That's why a bare agent isn't enough. It needs three things a chatbot never had:

1. Rules — what's allowed, what isn't, which invariants must always hold.
2. Verification — someone (or something) has to confirm the step didn't break the neighboring code.
3. A circuit breaker — a hard stop before anything irreversible.

That's exactly what the engine adds on top of the agent.

When you need it

• A one-off question like "how do I write this regex" — a chatbot is plenty.
• Work inside a real project with existing code, a database, and live users — you need an agent, and it absolutely needs discipline.

What this looks like on qvib.pro: input → what the engine does → result

The Quest engine is a "discipline firmware" for your agent. It doesn't replace the agent, it makes the agent reliable.

Input (one sentence to an agent that already has the engine installed):

"Fix the bug: deleting a task sometimes throws a 500."

What an agent WITH the engine does (unlike a bare agent, which immediately starts patching the first suspicious line it sees):

1. The debugger role reproduces the bug — first a failing test or exact repro steps, or a Sentry trace for production. No guesswork edits before reproduction.
2. It hunts the root cause, not the symptom, and greps out EVERY place with the same class of error — so it doesn't patch one instance and leave three neighbors behind.
3. A minimal fix plus a regression test that was red before and green after — proof the bug is actually closed.
4. The circuit breaker is in place. If the agent decides along the way to run git reset --hard or DROP TABLE, the hook guard blocks it before execution (in Claude Code — hard, via exit code).
5. A second, skeptical voice checks: did a function signature change in a way that broke its callers? Is error handling still there? It runs verify itself.

Result:

The bug is closed at the root, the whole class of the problem is cleaned out, there's a regression test, and the neighboring code still works — all of it backed by proof, not by "seems fixed."

Honest limits

• The agent's tools are your client's tools (Claude Code / Cursor / VS Code). The engine doesn't give the agent new hands; it gives it discipline, roles, and rules for using the hands it already has.
• Secrets. The engine never puts key values into files — only ${NAME} placeholders; the values live in your environment.
• Where the block is hard and where it's just an instruction. The dangerous-command circuit breaker works as a hard block today only in Claude Code (PreToolUse hook). On Cursor/AGENTS the same prohibitions are strict text the model follows, but without a physical block. A portable git/CI-level breaker for all targets is on the roadmap.
• Quality still depends on the model. The engine is a very detailed instruction set, not the executor itself: we don't run the model for you. We reduce the dependence on model "strength" by writing behavior out as a literal recipe, but we can't guarantee the result the way a service with its own execution layer would.