We've all been there.

Detailed Analysis

A Reddit post titled "We've all been there" surfaces a small but telling anecdote from a developer using Claude to build an application — apparently one involving billing or percentage-based calculations, possibly a point-of-sale or invoicing tool. The poster describes catching a bug during testing: after fat-fingering "100200" into a percentage field, the application happily saved the value without validation, which in a real transaction could have resulted in billing a customer a thousandfold more than intended. In response, the developer added a safeguard that Claude itself had not proactively suggested — capping the percentage input field at 1000%.

The anecdote, while lightweight, captures a recurring theme in developer discourse around AI coding assistants: large language models like Claude are highly effective at generating functional code quickly, but they don't always anticipate edge cases or defensive validation logic unless explicitly prompted. Input sanitization, bounds-checking, and guarding against user error are exactly the kind of "boring but critical" engineering practices that experienced developers know to build in reflexively, but which an AI assistant — optimized to fulfill the literal request — may skip unless the developer thinks to ask for them. The phrase "we've all been there" resonates because it frames this not as a Claude-specific failure, but as a familiar rite of passage in software development: shipping something that technically works until a user (or tester) does something unexpected.

This matters in the broader context of AI-assisted coding because it underscores the current division of labor between human developers and AI tools like Claude Code, Cursor, and other coding copilots. These tools have dramatically accelerated the pace at which functional prototypes and features can be built, but they still generally require a human in the loop to catch logic gaps, security vulnerabilities, and business-rule edge cases — particularly ones involving money, permissions, or irreversible actions. A billing system that silently accepts a 1000x overcharge is a low-stakes example in a testing environment, but the same class of oversight in production financial software, healthcare systems, or authentication flows could have serious consequences. The anecdote is a small data point in an ongoing conversation about whether AI coding assistants can be trusted to reason about failure modes and adversarial inputs as reliably as they generate happy-path functionality.

More broadly, this fits into a growing trend of "vibe coding" culture — where developers, including non-experts, lean heavily on conversational AI to scaffold entire applications quickly, sometimes without deeply reviewing the generated logic. As tools like Claude become more capable and more widely used for rapid prototyping, community-shared anecdotes like this one serve an informal but valuable function: they crowdsource awareness of common AI blind spots (like missing input validation) and reinforce the norm that human review, testing, and explicit constraint-setting remain essential steps even when the bulk of the code is machine-generated. Anthropic and competing labs have increasingly emphasized agentic coding capabilities and improved reasoning about edge cases in newer model releases, but posts like this suggest that vigilance around validation and boundary conditions is still very much a shared responsibility between AI and developer.