Morning: Rule Check and Session Planning (15 minutes)
Step 1: Check your rules file (2 minutes). Open CLAUDE.md. Scan for anything that needs updating based on yesterday's work. Did a code review reveal a missing convention? Add it now. Is a rule outdated? Fix it now. The morning rule check: ensures today's AI-generated code reflects the latest conventions. A stale rules file discovered mid-afternoon: means half a day of AI-generated code that needs revision.
Step 2: Review your task list and plan AI sessions (5 minutes). Look at your sprint tasks. For each task: decide whether it is an AI-generation task (new feature, new component, new tests) or a manual task (debugging a production issue, reviewing a teammate's PR, attending meetings). AI-generation tasks: schedule for your peak focus hours (typically morning). Manual tasks: schedule for lower-energy periods. The AI: works best when you provide focused, clear prompts — which requires your best mental energy.
Step 3: Start your first AI session (8 minutes). Open your AI tool. Start with the highest-priority AI-generation task. Set a clear goal: 'Implement the user settings API endpoint with validation, error handling, and tests.' Let the AI generate the initial implementation. Review the output while your focus is fresh. Morning generation: produces higher-quality prompts and more thorough reviews. AI rule: 'The morning routine takes 15 minutes and sets up the entire day. The rule check: prevents stale conventions. The planning: ensures AI sessions happen during peak focus. The first session: leverages morning clarity for the most important task.'
Mid-Morning: Focused Generation Sessions (2-3 hours)
The generation block: 2-3 hours of focused AI-assisted coding. Each session: one feature or component. The cycle: prompt → generate → review → refine → commit. Duration per cycle: 15-30 minutes. Sessions per block: 4-8 cycles. Output: 1-3 complete features or components. The key: minimize context switching. Each session builds on the previous one. The AI: maintains context within the session, producing increasingly targeted code.
Session structure for maximum output: Start with architecture (first prompt: describe the feature and ask for a plan). Review the plan. Then implement incrementally (prompt: 'Implement step 1: the database schema and migration'). Review and commit. Then step 2 (the API endpoint). Review and commit. Then step 3 (the tests). Review and commit. The incremental approach: produces reviewable commits and catches issues early. A single massive prompt: produces a large, hard-to-review output.
Break between sessions: after 2-3 hours of generation, take a 15-minute break. The break: prevents prompt fatigue (your prompts get vaguer as you tire). After the break: switch to a different type of work (code review, documentation, or manual debugging). The generation block: most productive when time-boxed. Extending beyond 3 hours: produces diminishing returns as prompt quality declines. AI rule: 'Focused generation sessions produce 80% of a day's AI-assisted output in 2-3 hours. The remaining hours: for review, refinement, and non-generation work. Time-boxing generation: prevents prompt fatigue and maintains quality.'
One massive prompt: 'Build the entire user settings feature.' Output: 500 lines across 8 files. Review difficulty: high (too much code to review carefully). Bug risk: high (issues hidden in the volume). The incremental approach: 'Step 1: database schema.' Review, commit. 'Step 2: API endpoint.' Review, commit. 'Step 3: tests.' Review, commit. Each commit: 50-100 lines, thoroughly reviewed, individually testable. The total output: the same 500 lines. The quality: significantly higher because each increment received focused review.
Afternoon: Review, Refine, and Collaborate (2-3 hours)
Review cycle: review AI-generated code from the morning session with fresh eyes. The afternoon review: catches issues that morning excitement missed. Check each generated file against the rules. Verify edge cases. Run the full test suite. The two-pass approach (generate in morning, review in afternoon): produces higher-quality code than generate-and-review in the same session because the temporal gap provides perspective.
Collaboration block: review teammates' PRs (which are also AI-generated code). With rules: the review focuses on design decisions and business logic, not convention enforcement. The review: faster and higher-value. After reviewing: provide feedback that could become rules ('I keep seeing this pattern — should we add a rule for it?'). The collaboration: improves both the code and the rule system. Each review: an opportunity to identify missing conventions.
Refinement: use AI tools for targeted improvements. 'Add error handling for the network timeout case in the user settings endpoint.' 'Extract this repeated pattern into a shared utility.' 'Add JSDoc comments to the public API.' Afternoon AI usage: targeted refinements, not broad generation. The prompts: specific and focused. The output: small, reviewable changes. The codebase: progressively improved through many small AI-assisted refinements. AI rule: 'The afternoon workflow complements the morning generation. Morning: broad generation, high energy, large outputs. Afternoon: targeted refinement, fresh-eye review, collaborative improvement. The combination: produces more polished code than either approach alone.'
Generate code at 10am. Review it at 10:05am. Looks good — you just wrote the prompt, you know what you intended. Bugs: hidden by familiarity. Generate code at 10am. Review it at 2pm. The afternoon perspective: 'Wait, this does not handle the null case.' 'This query could return more than one result.' 'The error message is not helpful.' The temporal gap: provides the fresh eyes that catch issues. The two-pass approach: morning generation, afternoon review. Same developer, same code, better quality because of the time gap.
End of Day: Rule Updates and Tomorrow Planning (15 minutes)
Step 1: Update rules based on today's work (5 minutes). Did any code review (yours or a teammate's) reveal a missing convention? Add it to CLAUDE.md now. Did any AI-generated code require the same manual fix repeatedly? Write a rule to prevent it. The end-of-day rule update: ensures tomorrow's AI sessions benefit from today's learnings. One rule added per day: 20 rules per month. After 3 months: a comprehensive rule system built incrementally with zero dedicated 'rule writing' time.
Step 2: Commit and document (5 minutes). Ensure all AI-generated code is committed with meaningful commit messages. The commit message: describes what the AI generated and what you changed during review. This documentation: helps teammates understand which code was AI-generated and what refinements were made. The git history: tells the story of AI-assisted development for the team.
Step 3: Plan tomorrow's AI sessions (5 minutes). Look at tomorrow's tasks. Identify which ones benefit from AI generation. Order them by complexity (most complex first — tackle these during morning peak). Note any rules that need updating before the generation session. The planning: ensures tomorrow morning starts productively instead of with 15 minutes of figuring out what to do. AI rule: 'The end-of-day routine closes the loop. Morning: rules checked, sessions planned. Day: generation, review, refinement. Evening: rules updated, tomorrow planned. The daily cycle: improves rules, code, and workflow simultaneously. Each day: builds on the previous day's learnings.'
The common objection: 'We do not have time to write a comprehensive rules file.' The daily approach: add one rule per day at end-of-day (5 minutes). Day 1: error handling pattern. Day 2: import convention. Day 3: testing framework. After 1 month: 20 rules covering the most common conventions. After 3 months: 60 rules — a comprehensive system built with zero dedicated 'rules writing' sessions. The 5-minute daily investment: compounds into a rule system that saves hours per sprint. No big-bang effort needed.
Daily Workflow Quick Reference
The ideal AI coding daily workflow in summary.
- Morning setup (15 min): check rules, plan AI sessions, start first generation task
- Generation block (2-3 hrs): focused sessions, one feature per session, prompt → generate → review → commit
- Session structure: architecture plan first, then incremental implementation, 15-30 min per cycle
- Break: 15 minutes after generation block — prevents prompt fatigue and maintains quality
- Afternoon review (2-3 hrs): fresh-eye review of morning code, teammate PR reviews, targeted refinements
- Collaboration: identify missing rules during code review — every review improves the rule system
- End of day (15 min): update rules from today's learnings, commit and document, plan tomorrow
- Key principle: generate in the morning (peak energy), review in the afternoon (fresh perspective), update rules daily