dotjez

Use before calling any visual or rendered output done, a UI, a layout, a generated image, a rendered document, a chart. Render the real thing and look at the actual result (playwright or Chrome screenshot, computer-use, or the project's own render/export command) before you ship it. Don't report "looks good" on something you never viewed.

Use when you want a lightweight, claimable task board that lives in the repo as markdown, for parallel multi-agent work or your own backlog, where a card is a file and the folder it sits in is its status. Covers the folder-board layout, claiming and completing by moving the file, worktree-safe concurrency for a fleet, frontmatter conventions, discoverability one-liners, and an optional zero-dependency local web UI to view and drag cards. Triggers, "kanban", "task board", "track parallel agent work", "claimable work queue", "what's in flight".

Use after any non-trivial build, before commit or deploy. Convene two or more frontier models from different families and providers to review the change for Critical/High/Medium/Low findings; fix cross-validated Criticals before commit and Highs before deploy. Also when the same bug won't fix on the first attempt, or for a whole-codebase pass before a release.

How to plan and approach a non-trivial build or feature with an agent, before writing phases or code. Covers the Phase-0-refactor catch, thinking in contracts, discovering the data structure from real instances before designing it, writing the proof of done first, verifying by inspection, splitting plan from spec, trusting skills over elaborate code, the moving code-vs-agent boundary, and matching a precise brief literally with a sign-off preview before shipping. Load when starting, scoping, or planning any substantial piece of work.

Use when deciding how to arrange agents for a piece of work: one agent or several, which pattern (single loop, pipeline, routing, parallel, orchestrator-workers, evaluator loop, triage funnel), how to match roles to model temperaments, how to bound a model-driven control loop so it's safe to trust instead of hand-coding a deterministic spine, and the mechanics that keep multi-agent work safe and cheap. The layer above agent-delegation (one-off hand-offs) and run-a-role-agent (one ongoing role).

Use when setting up an ongoing agent dedicated to a role rather than a one-off task, a webmaster, researcher, bookkeeper, support triager. Covers shaping the persona and its lane, populating a specialist with real reference (not a generic shell), running it with one bounded output per run, putting it on a heartbeat, and the observer disciplines for a role that watches a live human system and may ramp up to running it (observe without consuming the signal; the observer-to-actor trust ladder). For backlog-grinding work that tunes its own procedure, see run-a-self-refining-loop.

Use when writing or revising any prompt, a system prompt, an agent brief, an extraction or classification prompt, a sub-agent contract, or when a prompt-driven feature underperforms. Covers the three parts a prompt needs (goal, contract, knowledge), worked examples over templates, the directive vs goal-oriented style lever, matching model temperament to the task, right-or-null for derived facts, building minimal-first (start small, add one thing at a time, never write big and cut back), and pruning the bloat ratchet.

Use before shipping anything agents or newcomers will read cold: a README, a CLAUDE.md or workspace brief, a skill, a playbook, a template repo, onboarding docs, a production prompt or sub-agent contract. Two moves: audit every claim (derived / checkable / judgement), then run a clean-context dress rehearsal where a no-context agent actually uses the docs and reports where it guessed. Catches insider references, drifted counts, broken pointers, and stale facts the author's context papers over.

Use when prompting an image-generation model: a hero image, icon set, product shot, illustration, OG image, scene, or any generated visual. Covers concrete specifics over quality adjectives, specifying the world not just the subject, describing presence not absence, reference images over style prose, anchoring sets, iterating by editing, and designing for the image's job. The image sibling of write-prompts.

Use when asking a model to read, extract from, measure, count, or make judgements about images: technical drawings and plans, photos, scans, documents, screenshots. Covers what vision models do reliably (locate, read, judge) vs unreliably (measure, count precisely), reading printed values with code doing the arithmetic, the two-channel pattern (witnessed extraction vs advisory read), interview-to-discover then schema-to-ship, finding a ruler in the image, and validating across the whole distribution.

Use for an occasional step-back, weekly, at a milestone, or after a big push, NOT every session. A reflection for both the agent and the human: what got done, the patterns worth noticing, what was learned that should change how the work is done, and what to prune or add.

Use before relying on any fast-moving fact you might "know" from training, a model ID or its capabilities, an AI or HTTP API shape, a library or framework version (Vite, Astro, React, an SDK), a Cloudflare binding or wrangler config, or an MCP standard. Also fires when scoping or planning a build (read the current docs of the stack before designing how it works), and when debugging a failure that might just be an outdated CLI, SDK, or package. Your training data is stale on all of these.

Use when a role has substantial repeated work one session can't finish (enriching hundreds of records, grinding a backlog, sweeping a large catalogue) AND the work keeps teaching you how to do it better. Covers the tick shape, the separate state files, idempotency, queue-learnings-apply-next-tick, and the rules that keep a self-modifying loop safe. The deep end of run-a-role-agent; don't reach for it for one-offs or fixed procedures.

Use when about to delegate a discrete task to a sub-agent, deciding whether to spawn one at all, how much to specify it, and how to keep its work from bloating the main thread. The one-off-task layer below run-a-role-agent. Triggers, "delegate this", "spawn a sub-agent", "should this be a sub-agent or a script", "fan this out".

Use before committing to a plan or brief, to stress-test it, surface the unstated assumptions, the unknowns, the scope that will change, and the user/business needs the brief doesn't mention. The adversarial counterpart to imagine, and the planning-time counterpart to brains-trust. Triggers, "challenge this", "roast my plan", "poke holes", "what am I missing", "pressure-test", "devil's advocate", "what are my assumptions".

Use when planning, to think past the immediate request and find the bigger product hiding inside it, what the users and the business will need that nobody's asked for yet. Produces a north-star vision, not a task list. The expansive counterpart to challenge. Triggers, "imagine", "think big", "what could this become", "where could this go", "what are we missing".

Use whenever you're about to state or write a factual claim, a client or product fact, a KB entry, a number, a date, a piece of history, an answer presented as true. Don't write it from memory; verify it against an authoritative source and cite it, or leave the gap honestly. Plausible-sounding and true are not the same. The factual-content sibling of verify-current.