vibe-production-mindset
npx machina-cli add skill ash1794/vibe-engineering/production-mindset --openclawvibe-production-mindset
The gap between "works on my machine" and "works in production" is where incidents live.
When to Use This Skill
- Starting any implementation that will run in production
- When implementing API endpoints, data processing, or user-facing features
- Before declaring a feature "done"
- When the user cares about production quality
When NOT to Use This Skill
- Prototypes or spikes explicitly marked as throwaway
- Internal scripts that run once
- Test code (different quality criteria)
- When the user says "just get it working"
The Checklist
Imagine this code serves 1 million users. Check:
1. Observability
- Structured logging at key decision points (not just errors)
- Tracing/correlation ID propagated through the request
- Metrics for key operations (latency, success/failure counts)
- Alerts defined for anomalies
2. Error Handling at System Boundaries
- External API calls have timeouts
- External API calls have retries with backoff
- File I/O handles "file not found" and "permission denied"
- Network errors are handled (connection refused, timeout, DNS failure)
- Database errors are handled (connection lost, constraint violation)
3. Input Validation
- All external input validated before processing
- Size limits on string/array inputs
- SQL injection prevention (parameterized queries)
- XSS prevention (output encoding)
- Authentication checked before authorization
4. Graceful Degradation
- Circuit breakers for external dependencies
- Fallback behavior when dependencies are unavailable
- Graceful shutdown (drain connections, finish in-flight)
- Health check endpoint
5. Resource Management
- Connections closed/returned to pool
- Goroutines/threads have lifecycle management
- Memory bounded (no unbounded growth)
- File handles closed
Steps
- Read the implementation
- Run through the checklist — not every item applies to every feature
- Flag gaps — only for items that DO apply
- Recommend fixes — specific, not generic
Output Format
Production Readiness: [Feature Name]
Overall: READY / NEEDS_WORK / NOT_READY
| Category | Status | Gaps |
|---|---|---|
| Observability | ✓/◐/✗ | [count] |
| Error Handling | ✓/◐/✗ | [count] |
| Input Validation | ✓/◐/✗ | [count] |
| Graceful Degradation | ✓/◐/✗ | [count] |
| Resource Management | ✓/◐/✗ | [count] |
Critical Gaps
- [Gap with specific file:line and fix suggestion]
Note
This is NOT about over-engineering. It's about not under-engineering the critical paths. A simple feature should have simple production hardening — logging, error handling, and input validation. Not every feature needs circuit breakers.
Source
git clone https://github.com/ash1794/vibe-engineering/blob/master/skills/production-mindset/SKILL.mdView on GitHub Overview
vibe-production-mindset helps teams bridge the gap between 'works on my machine' and 'works in production' by enforcing a production-ready mindset. It centers on observability, error handling at system boundaries, input validation, and graceful degradation to prevent incidents when the product scales.
How This Skill Works
Before starting, imagine this code serves 1 million users, then apply a five-part checklist: Observability, Error Handling at System Boundaries, Input Validation, Graceful Degradation, and Resource Management. Read the implementation, run through applicable checklist items, flag gaps, and recommend concrete fixes.
When to Use It
- Starting any implementation that will run in production
- Implementing API endpoints, data processing, or user-facing features
- Before declaring a feature 'done'
- When the user cares about production quality
- Planning production-ready refactors or upgrades
Quick Start
- Step 1: Read the implementation
- Step 2: Run through the checklist — not every item applies to every feature
- Step 3: Flag gaps — only for items that DO apply; recommend concrete fixes
Best Practices
- Define observability at key decision points with structured logging, tracing, and metrics for latency and success/failure counts
- Ensure external API calls have timeouts and retries with backoff
- Validate all external input, enforce size limits, use parameterized queries, and apply output encoding to prevent XSS
- Design for graceful degradation with circuit breakers, fallbacks, and health check endpoints
- Manage resources by closing connections, lifecycle-managing goroutines/threads, and preventing unbounded memory or file handle leakage
Example Use Cases
- Add structured logging and correlation IDs to a new API endpoint to enable end-to-end tracing
- Implement timeouts and exponential backoff for an external payment gateway integration
- Validate and sanitize user input in a data ingestion service, with parameterized queries to prevent SQL injection
- Introduce a circuit breaker and fallback path for an unreliable third-party email service
- Enable graceful shutdown for a streaming job, draining in-flight work before termination
