Rules Verification (Items 1-3)
Item 1: Pull latest CLAUDE.md (30 seconds). Run git pull to ensure you have the latest rules. A teammate may have updated the rules yesterday evening. Starting with stale rules: means your AI generates code using outdated conventions. The pull: takes 30 seconds and prevents hours of rework. If you are the only developer: skip this step. If your team has 2+ people: never skip this step.
Item 2: Scan rules for today's domain (1 minute). Check if CLAUDE.md covers the domain you will work on today. Building a payment feature: are there payment-specific conventions (currency handling, decimal precision, PCI considerations)? If not: add them now (2-3 rules, 5 minutes). Building a standard CRUD feature: the existing rules likely cover it. The scan: identifies gaps before they cause convention violations.
Item 3: Check rule synchronization across tools (30 seconds). If you use multiple AI tools: verify that CLAUDE.md, .cursorrules, and copilot-instructions.md are in sync. Quick check: compare the last-modified dates. If they differ: one was updated without synchronizing the others. The fix: synchronize now. The cost of skipping: different AI tools generating code with different conventions for the same project. AI rule: 'Rules verification takes 2 minutes and prevents the #1 cause of wasted AI coding time: stale or missing conventions. Two minutes of checking beats two hours of convention rework.'
Context Preparation (Items 4-6)
Item 4: Review yesterday's open PRs (2 minutes). Check if any PRs you submitted yesterday have review comments. If convention-related comments exist: they indicate a missing rule. Add the rule to CLAUDE.md before starting today's generation. The pattern: yesterday's review comments become today's rules. The result: the same convention violation never occurs twice.
Item 5: Identify today's generation targets (1 minute). List the specific features, components, or modules you will generate today. Be specific: not 'work on the notification system' but 'generate the notification preferences API endpoint, the notification list component, and the notification service tests.' Specific targets: produce specific prompts. Specific prompts: produce better AI output. Vague targets ('work on stuff'): lead to vague prompts and generic output.
Item 6: Gather reference files (1 minute). For each generation target: identify which existing files the AI should reference. The notification preferences endpoint: reference the existing user preferences endpoint (for pattern consistency) and the notification schema (for data structure). Having reference files ready: means your first prompt includes the right context. Without reference files: your first 2-3 prompts are spent helping the AI find the right patterns. AI rule: 'Context preparation takes 4 minutes and eliminates the first 15 minutes of fumbling that happens when you start an AI session without preparation. Four minutes invested, fifteen minutes saved — and the first output is higher quality.'
You submitted a PR yesterday. The reviewer commented: 'We use zod for validation here, not manual checks.' That review comment: a missing rule. This morning: add 'All API input validation uses zod schemas' to CLAUDE.md. Today's AI generation: includes zod validation automatically. The reviewer: never writes that comment again. The pattern: check PR comments every morning, convert convention feedback into rules. Each morning: the rule system absorbs yesterday's learning. After 20 mornings: 20 fewer recurring review comments.
Tool Readiness (Items 7-8)
Item 7: Verify your AI tool is working (30 seconds). Open Claude Code, Cursor, or your AI tool of choice. Send a quick test prompt ('What conventions does this project use?'). If the tool reads your rules and responds correctly: ready. If the tool is not responding, has an expired session, or is not reading rules: fix it now. Discovering a broken tool setup 30 minutes into a generation session: wastes the entire session setup time.
Item 8: Clean your working directory (1 minute). Run git status. Commit or stash any uncommitted changes from yesterday. A clean working directory: gives the AI a clear picture of the codebase. Uncommitted changes: may confuse the AI (it sees files in a transitional state). The clean state: ensures AI-generated code is based on the committed codebase, not a work-in-progress. Also: run your test suite briefly (or at least the relevant test files) to confirm the codebase is in a green state before generating new code.
The readiness check matters because AI tools operate on your project state. A broken tool: wastes your peak morning energy troubleshooting. A dirty directory: produces AI code that conflicts with uncommitted changes. A failing test suite: means AI-generated code is built on a broken foundation. Two minutes of readiness: ensures the generation session starts clean. AI rule: 'Tool readiness takes 90 seconds and prevents the frustrating scenario where you compose a perfect prompt, hit enter, and discover the tool is not configured correctly. Check first, prompt second.'
Uncommitted files in your working directory: the AI sees them as part of the project state. A half-written migration file from yesterday: the AI references it when generating database code. An experimental branch with renamed types: the AI uses the new names that do not exist on main. The result: AI-generated code that conflicts with the actual codebase. The fix: git stash or commit before starting your AI session. The AI: generates code based on a clean, consistent project state. One minute of cleanup: prevents confusing AI output all morning.
Session Goal Setting (Items 9-10)
Item 9: Set a time box for the morning generation session (30 seconds). Decide: 'I will generate code for 2 hours, then switch to review.' The time box: prevents generation fatigue (prompts get vaguer over time). Without a time box: you generate until you are tired, producing diminishing-quality code in the last hour. With a time box: you stop at peak quality and switch to a different activity. The optimal generation time box: 2-3 hours for most developers.
Item 10: Write your first prompt before opening the AI tool (1 minute). Draft your first prompt on paper, in a note, or in your head: 'Create the notification preferences API endpoint that handles GET (list preferences), PUT (update preference), with zod validation, Result pattern error handling, and integration tests.' The pre-written prompt: specific, complete, and references the project's conventions. Prompts written after opening the AI tool: tend to be vague ('create a notification endpoint') because the tool's chat interface encourages quick, informal writing.
The complete checklist takes under 10 minutes. The return: a morning generation session that starts with the right rules, the right context, the right tools, and the right goals. Without the checklist: the first 15-20 minutes are spent discovering missing rules, finding reference files, fixing tool issues, and figuring out what to build. With the checklist: the first prompt produces convention-compliant, well-targeted code. AI rule: 'The morning checklist is not about being thorough — it is about being fast. Ten items, ten minutes, zero wasted time in the generation session. The checklist pays for itself before the first AI response arrives.'
Open AI tool first, then think about what to ask: 'uh, make a notification thing.' The tool's chat interface: encourages quick, informal, vague input. The output: generic and misaligned. Write the prompt first, then open the tool: 'Create the notification preferences API endpoint with GET (list) and PUT (update), zod validation, Result pattern errors, and integration tests referencing the user preferences endpoint pattern.' The pre-written prompt: specific, complete, convention-aware. One minute of pre-writing: transforms the quality of the first AI response from 'needs rework' to 'ready for review.'
Morning Checklist Quick Reference
The complete 10-item AI coding morning checklist.
- Item 1: Pull latest CLAUDE.md (30s) — ensure you have the team's latest rules
- Item 2: Scan rules for today's domain (1 min) — add missing conventions for today's work
- Item 3: Check rule sync across tools (30s) — verify CLAUDE.md matches .cursorrules matches copilot-instructions
- Item 4: Review yesterday's PR comments (2 min) — turn convention comments into new rules
- Item 5: Identify generation targets (1 min) — list specific features/components to generate
- Item 6: Gather reference files (1 min) — identify existing files the AI should reference
- Item 7: Verify AI tool is working (30s) — test prompt to confirm rules are loaded
- Item 8: Clean working directory (1 min) — commit/stash changes, verify tests pass
- Item 9: Set time box (30s) — decide when to stop generating and switch to review
- Item 10: Write first prompt (1 min) — draft a specific, complete prompt before opening the tool