Engineering Judgment Coach
Makes an AI coding agent pause and reason like a senior engineer before writing code — right layer, reuse over rebuild, the right pattern, and honest refactor timing.
Engineering Judgment Coach is a free AI skill for code improvement. Makes an AI coding agent pause and reason like a senior engineer before writing code — right layer, reuse over rebuild, the right pattern, and honest refactor timing. It works with Claude, Claude Code, Cursor and is ready to use out of the box.
About this skill
AI coding agents are fast at producing code and slow at knowing whether that code belongs where it's being put. This skill installs a short reasoning pass before any implementation: where in the codebase this change actually belongs, what already exists that could be reused instead of rewritten, whether a design pattern is genuinely warranted or just reflex, and whether the codebase has quietly reached the point where a refactor or framework change is the honest answer instead of one more patch. It produces a brief design note before code, not a lecture — fast enough to survive real usage, thorough enough to actually change what gets built.
What it does
Before writing or modifying code, the skill runs the request through a short internal checklist: identify the correct architectural layer, check for existing code or utilities that already solve part of the problem, decide whether a design pattern earns its complexity here or is over-engineering, and flag if the surrounding code has crossed a threshold where refactoring is the more honest move than adding another special case. It then writes the code consistent with that reasoning and surfaces the reasoning itself in a short design note.
What is included
- Full SKILL.md with the pre-implementation reasoning checklist
- A 'resist the pattern reflex' guide for telling genuine pattern fit from over-engineering
- Refactor-timing signals: concrete indicators that a change should trigger a refactor conversation instead of another patch
- Reuse-first checklist for searching the existing codebase before writing new code
- Worked example comparing a quick-patch approach against the judgment-first approach on the same request
How to use it
1. Download the engineering-judgment-coach-SKILL.md file 2. Add it to your agent's skills folder (e.g. .claude/skills/ for Claude Code, or upload it directly in a Claude.ai or Cursor chat) 3. Ask for a code change or new feature as you normally would 4. Read the short design note before the code — it names the layer, reuse decision, and pattern choice, and flags any refactor signal
Examples
Add a new notification type (SMS) to our app. We already have email and push notifications working.
Design note: this belongs in the existing NotificationService abstraction, not as a new standalone SMS module — reusing the same send/queue/retry interface email and push already implement. No new design pattern needed beyond the existing strategy interface; adding a third strategy is exactly what it was built for. One flag: the current NotificationService constructor is starting to take on a lot of provider-specific config (4 params now, 5 with SMS) — worth considering a config object before a fourth channel is added, but not urgent enough to block this change. Followed by the SMS notification class implementing the existing interface.
FAQ
Does this slow down every single coding request with a big design process?
How is this different from just asking Claude to "think step by step" before coding?
Will it block me from shipping a quick patch when that's genuinely the right call?
Does it need access to my whole codebase to check for reusable code?
Is this only for large codebases, or does it help on small projects too?
Can I use this alongside a code review or testing skill?
Related Skills
Code Refactoring Planner
Analyze a codebase or module and produce a safe refactoring plan with risks, boundaries, tests, migration steps, and acceptance criteria.
Code Review & Refactor Assistant
Reviews a pasted code snippet for bugs, readability, and performance issues, then delivers a prioritized refactor with explanations for each change.
Legacy Application Modernization Strategist
Create phased modernization strategies for legacy applications using risk, value, architecture, testing, migration, and operational evidence.
Related Prompts
Senior-Level Code Review & Refactor Plan
Get a structured senior-engineer-style code review covering correctness, performance, security, and maintainability, ending in a prioritized refactor plan.
Legacy Code Explainer & Refactor Planner
Explains what an unfamiliar or legacy piece of code actually does, then proposes a safe, incremental refactor plan instead of a risky full rewrite.
Behavior-Preserving Refactor Planner
Break a risky cleanup into verifiable steps that preserve user-visible behavior while improving an AI-built codebase.
Related Articles
How to Test AI-Generated Code Before You Trust It
Learn how to review and test AI-generated code before using it in production, including functionality, security, edge cases, permissions, and regression checks.