Chalermpon Ananwattanakit

There's a specific moment that happens with almost every project: the agent produces code, it passes your tests, everything's green, and there's a real pull to just move on to the next thing. Totally understandable, the whole appeal of this workflow is speed.

But there's a gap between "this works" and "I understand why this works," and that gap is where the real risk hides. Not because the code is wrong, most of the time it isn't, but because the next time something breaks nearby, you're debugging code you never actually read closely the first time.

during the BC (before ChatGPT) era, this gap barely existed. You wrote it, so you understood it, mostly by necessity. Now understanding is a separate step you have to choose to take, not something that comes free with writing the code yourself.

One habit that closes that gap fast: before merging anything non-trivial, ask the agent to explain its own implementation back to you, line by line, in plain language. Not as a formality, actually read the explanation. Two things tend to happen. Either it confirms your understanding and takes thirty seconds, or it surfaces an assumption you didn't know was baked in, which is usually the more valuable outcome.

Had Claude Code refactor our checkout flow to add an annual billing option alongside monthly. It worked in every test I ran, annual customers got charged correctly, monthly customers got charged correctly, everything looked clean.

What I didn't catch was a specific combination, someone applying a discount code and then switching plans before completing checkout, that caused the final price to recalculate against the wrong base amount. Instead of erroring out or defaulting to full price, it just quietly landed on zero.
Nobody typed in a hack, nobody exploited anything on purpose, the flow itself just handed out free subscriptions to whoever happened to click things in that particular order.

Took six days to notice, and only because I was manually checking Stripe for an unrelated reason and saw a cluster of $0.00 charges I couldn't explain. Roughly 40 people had gotten a free year of the product by the time I found it.
Fixing the bug was fast. Deciding what to do about the 40 people who were already in, upgrade them to properly paying, quietly let them keep it, reach out and explain, was the actually hard part.

Ended up honoring it for existing users and just fixing it going forward, felt like the least damaging option even though it cost real money.

Lately I've noticed most discussion around AI coding tools focuses on which assistant or terminal agent people use, but not much on the actual architecture decisions behind that, things like framework, hosting, database, and auth choices that affect cost and security down the line.

For context, my current default stack is Next.js on the frontend, Supabase for database and auth, Vercel for hosting, and Stripe for payments. I picked it mainly for speed of shipping and because it keeps infra costs predictable early on, but I'm not sure it's the best call for security or scaling past MVP stage.

A few things I'm curious about:

• Do you settle on a default stack before prompting your AI agent, or does the agent end up influencing your stack choice?

• What's been your biggest regret, cost, security, or scaling wise, with a stack you picked early on?

• Any stack you'd actively avoid for a new SaaS in 2026?