Based on our discussion, here is the summarized list of core friction points you are facing when trying to take “Vibe Coding” from a toy demo to a production-ready workflow:
1. Silent Intelligence Degradation
- The Phenomenon: As the session length increases or token usage rises, the model’s reasoning capability seems to “silently drop” (becoming dumber).
- The Root Cause: This is likely due to Context Window saturation (leading to “lost in the middle” issues) or the system quietly falling back to a smaller, cheaper model (e.g., from Pro to Flash) to manage latency or quotas.
2. The Security vs. Friction Zero-Sum Game
- The Phenomenon: You are stuck between two bad choices: enabling permissions leads to constant, flow-breaking popups, but “skipping permissions” leaves your local environment completely exposed.
- The Gap: There is a lack of Ephemeral Sandboxing (per-repo/per-task isolation). You need a mechanism where the Agent can run freely within a disposable container, rather than executing commands directly on your host machine.
3. Lack of Engineering Architecture
- The Phenomenon: The code generated by AI is often “flat” and script-like, ignoring clean architecture principles.
- The Gap: It fails to implement standard Layering (Handler Controller Store) and fails to define Interfaces first. This makes the generated code tightly coupled and nearly impossible to unit test or mock.
4. The “Demo-to-Prod” Gap
- The Phenomenon: “Vibe coding a demo feels great, but deploying it is impossible.”
- The Gap: The AI focuses on logic but ignores Operational Readiness. It misses:
- Deployment Configs: Differentiated K8s manifests for Dev/Staging/Prod.
- Observability: Standard Prometheus metrics and Alerting rules.
- Management: Admin debug endpoints.
5. Infrastructure Stack Heterogeneity
- The Phenomenon: Every company uses a different stack for Logging, Metrics, and Tracing (e.g., custom wrappers vs. standard libs).
- The Pain Point: AI models default to generic standard libraries (like
log.Println), which creates “un-engineering-like” code. This renders the output unusable in a corporate environment without heavy manual refactoring to inject specific internal middleware or SDKs.