*ChatGPT isn't making you ship code faster. It’s just making your codebase more verbose.
*
We are obsessed with "AI-generated apps." But we are ignoring the real bottleneck in web development. It isn't writing functions. It’s rebuilding the same 5 features for every single project:
❌ Auth ❌ Billing ❌ Admin Panels ❌ Waitlists ❌ Blogs
It gets worse. The waste isn't just in the first build—it's in the lock-in.
Current web development is fragile. We are constantly tossing out perfectly good logic just because it’s tightly coupled to the infrastructure:
- Switching frameworks? Rewrite.
- Changing databases? Rewrite.
- Moving from server to edge? Rewrite.
Everyone assumes the future is "Prompts in, Production apps out." But in reality? AI mostly automates syntax. You still have to architect the app. You still have to debug the glue code.
If you actually want to ship faster, stop looking for smarter prompts. Start looking for better building blocks.
The shift we need is Full-Stack Modularity.
We already did this on the frontend with Component Libraries. But the backend is still a mess of copy-pasting, and the "middle" is a mess of connecting APIs and managing server state.
Here are some of the best examples of building blocks that unlock modularity, framework agnosticism, and general abstractions available today:
Kysely: The unsung hero. It’s a type-safe SQL builder, but the real unlock is portability. It abstracts the data layer, meaning your backend logic works across Postgres, MySQL, or SQLite.
better-auth: Because Kysely exists, we now have portable logic. better-auth drops in session handling that plugs into your database (not a 3rd party black box). Secure, portable, and owned by you.
tRPC & TanStack Query: The connective tissue. tRPC solves the "Network Chasm" with end-to-end type safety. TanStack Query handles caching and hydration. Together, they eliminate 80% of your complex useEffect hooks.
shadcn/ui The standard for UI. It proved that we want to own our components, not just install them.
This is exactly why I spent the last 100 days building Better Stack (@btst).
I was tired of manually wiring these layers together every time I started a new project. I wanted to be able to install a "Blog" or "AI Chat" feature... and get the whole stack slice instantly:
✅ The Database Schema ✅ The API Routes ✅ The SSR Data Loaders ✅ The Page Routes
All in one typed, installable unit.
Look at the code in the images below. 👇
You aren't writing glue code. You are composing features. A CRUD backend with todos, blog, and AI chat, and a frontend with pages—in 20 lines of code.
"Is this Low-Code?"
No. And that’s the point.
Low-code abstracts too much and traps you.
AI Code guesses the syntax but misses the architecture.
Modularity lives in your node_modules. It respects your stack. It’s code-first, fully typed, and totally overridable.
The philosophy is simple: Stop writing glue code. Start assembling features.
We don't need to wait for AGI to write production apps. We just need to standardize how we share features.
Build with better blocks. 🧱
Top comments (0)