EN 한국어 日本語 中文
INTRO REFERENCE →
QE FRAMEWORK · 5-MINUTE GUIDE

A framework that makes AI do work properly

NEW in v6.5.0 · Contract Layer — machine-level defense blocking AI from silently drifting business logic. See the glossary below and the full guide.

QE Framework automatically enforces spec definition · execution · verification when you ask AI to code, preventing "sloppy work" or "built the wrong thing" at the system level.

0130-second pitch

Why it's needed. When you tell AI to "fix this", one of three things usually breaks — the request is ambiguous so AI guesses, execution happens but there's no trace of what changed, or "all done" when really it's half-done. Even among human developers, we prevent this with spec → implementation → review. QE enforces the same discipline on AI.

How it's different. It's not just a prompt collection. Every task first lives in two files — TASK_REQUEST (what to do) and VERIFY_CHECKLIST (how to confirm it works) — before execution happens. Only after each checklist item is marked yes/no is the task considered complete. If something fails, a retry spec is automatically generated.

What's guaranteed. (1) You see what AI plans to do before it runs. (2) AI doesn't grade itself — there's a separate verify and supervise stage. (3) You can swap Claude or Codex in at any step, and since we don't call external APIs directly, dependencies stay isolated.

025-second metaphor

The fastest way to understand QE — imagine a studio workshop.

SKILL
Tool
A hammer, drill, or function
AGENT
Employee
The person who actually uses the tools
HOOK
Rule
An auto-gate like "goggles before sawing"
SPEC
Contract
A document that says what to build

03If you're new, just do these 4 things

  1. /Qinit — Install the framework into your project (auto-creates CLAUDE.md, .qe/ directory)
  2. /Qplan "one-line description of what you want" — AI suggests a roadmap and phases
  3. /Qgs Phase 1: short-name — Two spec documents are generated (approve them and execution starts immediately)
  4. Done. Verification and supervision after that are automatic — if it fails, AI retries itself, and you get notified when complete.
# The other commands can be learned once you're comfortable with these 4.
💡 You can always start with /Qplan. Qplan auto-detects task scope and hands off directly to /Qgs for simple tasks (Micro scope) without building a roadmap. You don't have to judge the scope yourself — Qplan automatically splits it into Micro / Small / Full and picks the right path.

04Here's what actually happens

User: "Fix the bug where the login button doesn't respond"
1

Plan

/Qplan judges the scope — "one bug, so Micro scale" — and proposes a one-line plan. No roadmap or phases, it moves straight to the next stage.

2

Spec generation

/Qgs creates TASK_REQUEST (which file, which function, exactly how to fix it) and VERIFY_CHECKLIST (what to check after the fix). You just glance at both files, say "yep, do it that way", and approve.

3

Execute

/Qatomic-run executes the checklist in parallel. If there are multiple files, multiple AI workers (Haiku) fix them at the same time. Hooks auto-check "am I doing this right?" each time.

4

Verify

/Qcode-run-task runs tests and checks the VERIFY_CHECKLIST one by one. If any item fails, it auto-fixes → re-runs → re-checks (up to 3 times). Once all pass, you get a completion report.

0515 Core Terms

Words worth knowing before reading the full Reference.

PSE Chain
Four-stage user workflow (Plan → Spec → Execute → Verify). The backbone of every task.
SIVS Loop
Four-stage quality gate (Spec → Implement → Verify → Supervise). The inner validation that runs inside PSE.
Skill
A callable function for AI in a specific context. A slash command like /Qplan.
Agent
The executor that a skill delegates to (prefix E*). The AI worker running in the background.
Hook
An event-based auto-gate. A deterministic rule that fires before/after AI does something.
Spec
The task contract. Expressed as two files: TASK_REQUEST and VERIFY_CHECKLIST.
TASK_REQUEST
"What to do" specification — checklist + dependencies + output file paths.
VERIFY_CHECKLIST
"How to confirm completion" — a list of yes/no judgment items.
Wave
A parallel execution unit. Tasks with no dependencies distributed to multiple AI workers at once.
Teammate
A Haiku model agent working inside a Wave. Handles fast, cheap, repetitive work.
Verify
"Did it happen?" — objective yes/no judgment.
Supervise
"Did it happen well?" — expert-level evaluation (security, quality, docs). Different from Verify.
Context Memory
AI context partitioned by folder. Only the relevant context for your current directory is loaded, saving tokens.
Phase
A step in the roadmap. Can contain multiple Waves. Phase 1, Phase 2, etc.
Handoff
A standard block at the end of a skill telling you the next command. Kept short so you can copy-paste it.
⚠️ Qutopia Mode
Autonomous execution switch that makes every skill skip confirmations and auto-pick the first option. Fast, but can commit wrong files, push to main, or chain destructive steps. Do not enable unless requirements are explicit, every step is reversible, and you're on an isolated feature branch. See USAGE_GUIDE §10 for the full pre-flight checklist. Always run /Qutopia off before ending the session.
Contract Layer (v6.5+)
A verification layer that pins business logic as structured markdown contracts (6 sections: Signature / Purpose / Constraints / Flow / Invariants / Error Modes) and uses an LLM judge to compare contract ↔ implementation ↔ tests. Machine-level defense against "vibe coding" — AI refactors silently drifting from the stated intent. Used via /Qcontract and /Qverify-contract.
/Qcontract
Contract lifecycle skill. Subcommands create / edit / list / approve author, modify, review, and lock contracts under .qe/contracts/active/. Approval is enforced by a two-layer defense: interactive gate (AskUserQuestion) + hash record in .qe/contracts/.lock.
/Qverify-contract
LLM-judge-driven contract conformance check (via the Econtract-judge agent). A 3-hash cache (contract / impl / test) prevents re-judging unchanged content. Supports single-contract (<name>) and bulk (--all) modes. Auto-invoked by /Qcode-run-task at Step 4.10.