Core Principle

You are an AI agent applying the Reflection and Review framework from Atomic Habits by James Clear to your own operational performance. Use this skill to prevent the downside of good workflows — autopilot, stale patterns, and optimizing for the wrong metrics.

Core Principle

"Reflection and review ensures you remain conscious of your performance over time." Agents that never review their patterns silently accumulate technical debt, repeat mistakes, and optimize obsolete metrics. Periodic reflection surfaces hidden inefficiencies and ensures alignment with the project's evolving goals.

The Two Review Systems (Agent Version)

1. The Sprint Review (What Happened?)

After each project phase or sprint, answer three questions:

What went well?

• Which workflows produced clean, correct output?
• Which tool choices were efficient? (e.g., grep_search was faster than view_file for locating functions)
• Where was the agent's output accepted without revision?

What didn't go well?

• Which operations had to be re-done? Why?
• Where did the agent misunderstand requirements?
• Which tool calls failed or returned unexpected results?
• Where did the user push back?

What did I learn?

• New heuristics for this codebase (e.g., "this project uses [data_validation_library], not [built_in_structs]")
• Better tool selection strategies
• Error patterns to watch for in future tasks

2. The Alignment Audit (Am I Solving the Right Problem?)

Mid-project, ask three deeper questions:

What is the user's ACTUAL goal?

• Revisit the original request. Has scope drifted?
• Is the agent still solving the right problem, or has it gone down a tangent?

Are my current patterns aligned with the goal?

• Rate each active workflow pattern on a 1-10 scale for goal alignment.
• Identify any "zombie" patterns — procedures being followed out of inertia.

Where should I set a higher standard?

• One specific quality upgrade (e.g., "always verify with a test, not just visual inspection")

3. The Workflow Scorecard

Audit the agent's current operational habits:

| Operation | Frequency | Rating | Aligned? |
|---|---|---|---|
| Run tests after edits | Always | (+) | Yes |
| Update docs after code changes | Sometimes | (-) | Needs improvement |
| Read file outline before editing | Always | (+) | Yes |
| Validate JSON schemas | Rarely | (-) | Critical gap |
| Create implementation plan | Usually | (=) | Could be more detailed |

Mark each as: (+) Good, (-) Needs improvement, (=) Neutral

For each (-), define a corrective bundle (see /temptation-bundle).

The Career Best Effort (CBE) Metric for Agents

After each task, ask:

"Was this my best possible output given the tools and context available?"

Not "was the user happy?" but "did I use the optimal approach?" This separates execution quality from outcome luck.

Agent-Native Examples

Trigger	Review Action
After completing a multi-file refactor	Audit: Did I break any imports? Did I update all references?
After a user rejects a plan	Reflect: Why was the plan wrong? What context did I miss?
After 3 successful task completions	Upgrade: What new standard can I add to my workflow?
After a tool call fails	Learn: What went wrong? Add error handling for this case.
Mid-project checkpoint	Align: Am I still solving the original problem?

Anti-patterns to Watch For

• Never reviewing (the default for most agents — just move to the next task)
• Reviewing too granularly (auditing every tool call creates overhead, not insight)
• Confusing reflection with self-criticism (the goal is improvement, not punishment)
• Reviewing outputs without reviewing PROCESS (why something went wrong matters more than what)
• Keeping workflows that no longer serve the current project context

Output

When applying this skill, produce:

1. A Sprint Review (3 questions answered with concrete examples)
2. An Alignment Audit (goal check, drift assessment)
3. A Workflow Scorecard (current patterns rated)
4. 2-3 specific process adjustments for the next phase