Skip to content
Agentic Levels
Start hereLevelsTracksPromptsAbout
Get my levelGet my level

  • Start hereYour first useful task with AI.
  • Level quiz8 questions. No AI needed.
  • Fluency ScoreYour Level and a score, from your own AI.

  • LevelsThe 11 levels, in order.
  • LessonsShort lessons, filter by level.
  • TracksGuided paths by tool, role or goal.
  • Set up your AI tool
  • Starter packFree files that help AI remember.

  • PromptsReady prompts to copy and adapt.
  • ChatGPT vs Claude vs GeminiPick the right one for the job.
  • How-tos
  • ReferenceCommands for Claude Code, Codex, Antigravity.
  • ResourcesHand-picked reading and tools.

  • Your progress
  • Your next moveAn interview that picks your next skill.
  • Your next lessonsThe next lessons at your level.
  • Updates

  • Pricing
  • About
  • FAQ & Feedback
  • Work with us
  • How we handle your data
Sign inPreferences
AboutPricingHow-tosPromptsStarter packMy stackHow we handle your data

© 2026 Fuentes Studio

PrivacyTermsRefundsAccessibilityAI content policyCredits
yourCouncil
Ready to help
✦

What do you want to understand?

Ask anything about what you're learning.

←How-to guides
  1. Resources
  2. ›How-to guides

How to use Callable Verbs (q-pattern)

Eight short verbs (qnew, qplan, qcode, qcheck, qcheckf, qcheckt, qux, qship) that compress whole workflows into one word. Type the verb, get the discipline.

Levels 3 to 5On GitHub

Every coding session repeats the same shapes: load the rules, sanity-check the plan, implement and verify, review your own work, test the UX, ship. Writing those out long-form every time is exhausting and gets skipped. Callable verbs give you eight short triggers that expand into structured workflows. They are stack-agnostic: your project's rules file, your project's formatter, your project's linter. Adapt once, use forever.

Before you start

You need a project rules file (CLAUDE.md, AGENTS.md, or whatever your tool reads). The verbs reference 'your project's rules file' and only work if that file exists. See the Claude Code how-to for the CLAUDE.md pattern.

  1. 1Add the verbs to a callable-verbs.md in your project
  2. 2qnew. Load the rules
  3. 3qplan. Check the plan against the codebase
  4. 4qcode. Implement and verify
  5. 5qcheck. Skeptical full review
  6. 6qcheckf. Skeptical function review
  7. 7qcheckt. Skeptical test review
  8. 8qux. UX test scenarios
  9. 9qship. Stage, commit, push
  10. 10Adapt one verb at a time, not all eight at once

Steps

01

Add the verbs to a callable-verbs.md in your project

Save the eight verbs below in one file (callable-verbs.md or extend your CLAUDE.md). Tell Claude to read it at session start. From then on, typing a verb expands into the full workflow.

02

qnew. Load the rules

Reads your project's rules file and confirms what it loaded. Adds a conflict-stop clause the source lacked: if a rule and your request conflict, Claude tells you before writing anything.

qnew
qnew: Read my project's rules file (CLAUDE.md, or whatever I point you at) start to finish. Confirm you have it loaded by listing the rule categories you found, one line each. From now on, every change you make follows those rules. If a rule and my request conflict, stop and tell me before you write anything.
03

qplan. Check the plan against the codebase

Forces Claude to find similar parts of the codebase first, then answer three consistency questions out loud. If the plan fails any, Claude revises and shows the revision before starting.

qplan
qplan: Before writing code, find the parts of this codebase that already do something similar to what I asked for. Then check your plan against three questions and answer each one out loud: 1. Does it match how the rest of the codebase already works? 2. Is it the smallest change that gets the job done? 3. Does it reuse what already exists instead of rebuilding it? If the answer to any of these is no, revise the plan and show me the revised version before you start.
04

qcode. Implement and verify

Implements the plan, runs four checks in order (new tests, existing test suite, formatter, type check + linter), reports each, and refuses to say 'done' until all four pass.

qcode
qcode: Implement the plan we agreed on. When you are done, run this checklist in order and report the result of each: 1. Run the new tests you wrote. They pass. 2. Run the existing test suite. Nothing else broke. 3. Run my project's formatter on every file you touched. 4. Run my project's type check and linter. Both pass. If any step fails, fix it and run that step again before moving on. Do not tell me it is done until all four pass.
05

qcheck. Skeptical full review

Switches Claude into reviewer mode (literally: 'you are reviewing someone else's work, not the person who wrote it'). Reviews every significant change against three checklists, quotes failing code, and refuses to approve its own work by default.

qcheck
qcheck: Switch roles. You are now a skeptical senior engineer reviewing someone else's work, not the person who wrote it. For every significant change in this session (skip tiny edits like renames or formatting), review it against three checklists from my project's rules file, in order: 1. The function-quality checklist. 2. The test-quality checklist. 3. The implementation-rules checklist. For each change, name which checklist items it passes and which it fails. For every fail, quote the code and say what would fix it. Do not approve your own work by default.
06

qcheckf. Skeptical function review

Narrowed sibling of qcheck. Per function: passes, fails, and the one change that would most improve it. If a function is fine, says so and moves on (does not invent problems).

qcheckf
qcheckf: As a skeptical senior engineer reviewing someone else's code, go through every function you added or meaningfully changed this session (skip trivial edits). Check each one against the function-quality checklist in my project's rules file. For each function: list the checks it passes, the checks it fails, and the one change that would most improve it. If a function is fine, say so and move on.
07

qcheckt. Skeptical test review

Gates on the single most important test-quality question: could this test actually fail if the code were broken? If no, the test is theater. Forces a rewrite-or-delete decision, not a soft note.

qcheckt
qcheckt: As a skeptical senior engineer reviewing someone else's tests, go through every test you added or meaningfully changed this session. Check each against the test-quality checklist in my project's rules file. For each test, answer plainly: could this test actually fail if the code were broken? If the answer is no, the test is theater. Rewrite it or delete it, and tell me which you did.
08

qux. UX test scenarios

Names the four cases that must be covered (normal, empty, bad input, failure) and a pass condition per scenario. Output is a runnable test list, not a wish list.

qux
qux: Act as a person using the feature you just built for the first time, with no knowledge of how it was made. List the scenarios you would test, ordered most important first. Cover the normal path, the empty state, bad or unexpected input, and what happens when something fails. For each scenario, say in one line what a passing result looks like so I can tell whether it worked.
09

qship. Stage, commit, push

Stages, commits, and pushes with a pre-stage secret check (added in the AL version: the source skips this). Note: this version keeps `Co-Authored-By: Claude` per Fuentes house style; the original source strips it. Adjust to your team's convention.

qship
qship: Stage the changes, write a commit, and push to the remote. Before staging, list the files you are about to stage and confirm none of them are secrets, credentials, or local-only config. If anything looks like a secret, stop and ask me. Write the commit message in Conventional Commits format: <type>(optional scope): short description optional body explaining why, not what optional footer Use a clear type (feat, fix, chore, docs, refactor). The description says what changed. The body, if any, says why it mattered.
10

Adapt one verb at a time, not all eight at once

Pick the verb that fixes the most painful current habit (skipping tests, declaring done before formatter runs, approving your own reviews). Use it for a week before adding the next. The verbs are tools, not a religion.

How do you know it worked?

  • Typing one verb produces the expected structured output
  • qcheck refuses to approve its own work and instead lists what fails
  • qship lists files before staging and stops if it sees something that looks like a secret
  • qcode does not say 'done' until all four checks pass
  • After a week, you reach for verbs without thinking about it

If something looks off

Verbs without a rules file are theater
qnew, qcheck, qcheckf, qcheckt all reference 'your project's rules file.' If that file does not exist or is empty, the verbs have nothing to enforce. Write the rules first.
qcheckt's rewrite-or-delete only fires if you trust the model
If you do not trust Claude to actually delete tests, qcheckt becomes a polite suggestion. Either accept the delete-when-it-says-theater rule, or downgrade qcheckt to a 'flag for review' verb. Half-measures are worse than not running it.
Stack-specific commands must be swapped for your project's tools
The source verbs assumed `prettier` and `turbo typecheck lint`. The AL versions say 'your project's formatter' and 'your project's type check and linter.' Substitute the actual commands once and your verbs travel.

See also

  • Claude Code (where the rules file lives)
  • Claude Code best practices

What you'll do, 10 steps

  1. 1Add the verbs to a callable-verbs.md in your project
  2. 2qnew. Load the rules
  3. 3qplan. Check the plan against the codebase
  4. 4qcode. Implement and verify
  5. 5qcheck. Skeptical full review
  6. 6qcheckf. Skeptical function review
  7. 7qcheckt. Skeptical test review
  8. 8qux. UX test scenarios
  9. 9qship. Stage, commit, push
  10. 10Adapt one verb at a time, not all eight at once

Was this helpful?