AI Agent Workflow Collection

Use at the acceptance gate — verify the build by doing the user's flow yourself end-to-end and confirming persisted state, not by checking that "the parts exist per spec" or that a green suite ran.

Use when a build is proposed with no path to reach users — force distribution (channel + activation + retention loop) into the product decision. "Build it and they will come" is a failure mode, not a plan.

Use when AI coding agents will read/write this codebase, or an AI/LLM feature is proposed — design for the AI reader, defend against AI-accelerated drift, and treat AI-only-legible novelty as a token.

Use to turn a raw transcript/doc into structured knowledge — break it into nuggets (one observation + its receipt + a tag), then build themes UP from the codes; never a wall of notes or a top-down summary.

Use during the runtime adversarial pass — attack the build the way real users (and bad actors) actually behave: malformed input, concurrency, network failure, refresh/back, permissions you shouldn't have, and the second time, not just the first.

Use before you run anything — statically walk every user journey end-to-end (happy path plus the error, empty, returning-user, and cancel states) by reading flow + spec + code, to find where it's incomplete or breaks. A missing journey is a defect.

Use when documenting how to deploy, operate, or recover a service, or after learning something a release/incident taught you — write a runbook so good a competent stranger could ship or recover from it alone.

Use when a QUALIFIED deal stalls — "let me think it over," goes quiet, keeps asking for more info, won't commit. This is usually indecision (fear of a wrong choice), not status-quo bias. De-risk with JOLT; do NOT push urgency, which makes fear worse.

Use mid-cycle on any multi-stakeholder deal — map the buying committee, multi-thread across it, develop a real champion (power + self-interest), TEST them, and reach the economic buyer without burning your contact.

Use whenever you reach for a value (color, spacing, radius, type, motion) or build a component — extend tokens and shared components in place, never fork into one-off className soup. The system is what lets quality scale across surfaces.

Use when copy across surfaces is inconsistent or ad-hoc, when you need a reusable messaging framework the whole team can derive from (homepage, deck, ads, onboarding all ladder to the same core), to pressure-test whether a proof point actually discriminates (true-but-weak stats) or whether naming a customer/competitor is a good look, or to audit README/docs/changelog/marketing for drift against each other and against the real shipped surface.

Use whenever a load-bearing call is made (or asked again) — record problem, options, what was chosen, why, and what was rejected, so settled questions aren't re-litigated and "why did we do it this way?" always has an answer.

Use for build-vs-buy, adopting a new framework/database/language, or "should we use X" — apply the innovation-token test; default to the well-understood; a stack only the AI understands is a token spent.

Use when advancing a deal toward commitment — build a Mutual Action Plan working backward from go-live (including legal/procurement), drive each step, and ASK for the commitment plainly. Pursue commitment + advancement, never compliments.

Use when scoping any user-facing surface — require a whole-surface design up front; ship in slices, but each slice lands in its final place, nothing bolted on to be re-placed later.

Use when laying out any screen or composing a set of elements — make the eye go where it should. Establish visual hierarchy (one focal point, deliberate scan path), group with Gestalt, structure with a grid and whitespace, and disclose progressively. This is the affirmative craft, not just refusing slop.

Use BEFORE picking which questions matter — reweight the load-bearing themes by the company's category and stage. The themes are not equally important across categories; say the reweighting out loud in one line.

Use when more than one entry surface exists or is proposed (CLI, API, MCP, UI, webhook, cron) — make every surface route to one shared core code path, and run a DRY pass for the same thing hand-rolled twice.

Use when summarizing whether the bet clears the bar — explicitly tally how many unique insights it carries across tech, market, and GTM. One isn't enough; name which ones and why.

Use for the pitch, the launch story, the homepage hero, the keynote, the fundraising or vision story — any artifact that must move someone emotionally, not just inform. Build a strategic narrative with stakes.

Use when code does anything cryptographic — hashing passwords, encrypting data, signing tokens, generating randomness — catch the common crypto misuse and never let anyone roll their own.

Use to maintain the living body of knowledge — one findable source of truth, deduplicated, tagged to a stable schema, with each belief carrying its evidence, confidence, and any dissent. You propose updates; a human ratifies.

Use whenever something is broken, flaky, or behaving unexpectedly — find the root cause systematically (reproduce, isolate, hypothesize, verify) and fix the cause, not the symptom. Never shotgun-edit.

Use when defining what "success" means for a feature/initiative, when picking a metric, or when a number looks suspiciously good — choose a North Star + guardrails, reject vanity, and defend against Goodhart/gaming.