Learn Agile Practices

Almost every SaaS app inside Vercel has now been replaced with a generated app or agent interface, deployed on Vercel. Support, sales, marketing, PM, HR, dataviz, even design and video workflows. It’s shocking. The SaaSpocalypse is both understated and overstated. Over because the key systems of record and storage are still there (Salesforce, Snowflake, etc.) Understated because the software we are generating is more beautiful, personalized, and crucially, fits our business problems better. We struggled for years to represent the health of a Vercel customer properly inside Salesforce. Too much data (trillions of consumption data points), the ontology of Vercel was a mismatch to the built-in assumptions, and the resulting UI was bizarre. We generated what we needed instead. When you don’t need a UI, you just ask an agent with natural language. We’ve also been moving off legacy systems with poor, slow, outdated, and inconsistent APIs, as well as just dropping abstraction down to more traditional databases. UI is a function 𝑓 of data (always has been), and that 𝑓 is increasingly becoming the LLM.

LLMs have made code cheap. So now people are spinning up 10 agents working on 10 features in parallel. Sounds productive. But the tradeoff is obvious: the code quality is often spaghetti + over-engineered. LLMs behave like over-eager interns. They will do more than asked, add abstractions you didn’t need, and optimize for "completeness" over simplicity. Which means you end up babysitting anyway. For anything non-trivial, I have found you still need to spend 1–3 hours upfront: • defining scope • writing clear specs • thinking through system boundaries • setting constraints Otherwise, the system drifts. And even after that, you have to review the code. They still hallucinate patterns, introduce unnecessary layers, or miss edge cases, even with detailed instructions. A lot of people advocate "just let agents cook." In practice, you're often getting 60-70% unnecessary code that increases: • cognitive load • onboarding time • surface area for bugs • long-term maintenance cost For side projects, this is fine. But for real systems with shared codebases, multiple engineers, and production traffic, this compounds fast. We are already seeing: • unstable tools • memory leaks • constant crashes • frequent rewrites This isn't just "early days", it’s a direct result of speed > discipline. Spinning up 10 agents feels like productivity. But you are often just pulling forward the cost into refactoring hell. I would rather: build slower → keep systems simple → refactor less frequently Good engineering is still about what you choose not to build.

am i right or am i right