Add production-grade observability to code — structured logging, metrics, tracing, alerting, etc. Use this skill when the user is building or modifying a service that runs in prod. Triggers on phrases like "how will we know if this breaks", "production ready", or mentions of observability/metrics/etc. If you're building a new service, this skill should trigger.
Stop and analyze before writing any code. Review the problem space — trace what the change touches, estimate the blast radius, and mentally simulate the system with the change in place. Use this skill whene you're about to implement something that modifies existing behavior, touches shared components, or interacts with more than one part of the system. Triggers on implementation tasks (features, bugs, refactors). Even if the user says "just do it", take 60 seconds to load the context first.
Design error handling as a first-class concern, not an afterthought. Consider where failures get caught, what state they leave the system in, and what information flows to operators, callers, and users. Triggers on phrases related to errors, when you notice a critical piece of code without error handling, or when you're implementing a complex feature.
Analyze requirements for gaps, ambiguities, and unstated assumptions before implementing. This is "negative space analysis" — finding what the spec doesn't say that it should. Use this skill when you receive a task, ticket, user story, or feature request and need to identify specifics before implementing. Triggers on phrases like "build this feature", "implement this", "I want to...", or any time you're handed a task description that you need to start working from. The most expensive bugs come from building the wrong thing, not from building the right thing incorrectly — this skill prevents the former.
Conduct a blameless post-mortem analysis after an incident, outage, or significant bug. Use this skill when something went wrong in production and the team needs to understand what happened, why, and how to prevent it from happening again. Triggers on phrases like "post-mortem", "root cause analysis", "RCA", "what went wrong", "why did this break", or after resolving a production issue when the user wants to document learnings.
Design APIs with the discipline expected at companies known for great developer experiences. Use this skill when building new API endpoints, redesigning existing ones, or reviewing API contracts. Triggers on phrases like "design the API", "new endpoint", "API contract", "what should the API look like", any task that involves defining how systems communicate, or when building a feature that will expose an API. Good API design should happen before implementation, not after.
Design to accommodates the system's likely future, not just its present state. This is "temporal design" — reasoning about how today's implementation interacts with tomorrow's roadmap and evolving requirements. Use this skill when making decisions during implementation: where to place abstractions, how to structure interfaces, when to make something configurable vs. hardcoded. Triggers when you're choosing between approaches and the difference between them is how well they'll hold up over time.
Identify, catalog, and plan the resolution of technical debt in a codebase. Use this skill when the user wants to understand the health of their codebase, prioritize cleanup work, or plan a refactoring effort. Triggers on phrases like "tech debt", "code quality", "refactor", "cleanup", "code health", "maintainability", "this code is a mess", or when you notice code quality issues during implementation that should be tracked rather than fixed inline (which could result in a game of whack-a-mole).