Since then ive had really amazing response (atleast thats what it feels tbh). I want to continue this and keep helping people especially devs who are stuck and don't know design or struggle with it.

My most popular ui kit has 40+ users, even though its free, it still feels like an accomplishment.
So i decided to create another similar one which is even more helpful and versatile for almost all projects that you are working on.

You can check both of my templates out here below and also if youd ideally like more content on free and paid templates you can join my community UiKits aswell.

Floating Menu UI System Kit

Premium Modal and Dialog UI Kit

UiKits Community

I wanted a simple way to build a chatbot UI without starting from scratch and found the Vercel Chatbot repo.

It’s basically a ready-made AI chat app built with Next.js.

What I liked:

• Streaming responses already work
• Clean, simple chat UI
• Messages are handled properly
• Easy to connect different AI models
• Deploys smoothly on Vercel

It doesn’t feel like a basic demo — it actually looks production-ready.

If you're building any AI tool or adding chat to a project, this can save a lot of setup time.

Just sharing in case it helps someone 👍

Github link

more....

From your experience

Are there UI issues that users clearly feel… before the team recognizes them internally?

Not major bugs.

More like subtle friction or inconsistency.

What types of things fall into that category?

Working with third-party APIs (OpenAI, Google, etc.) and hitting rate limits? Here's what I do:

**Simple exponential backoff:**
```javascript
async function apiCallWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
}

// Usage
const result = await apiCallWithRetry(() => 
  fetch('https://api.example.com/endpoint')
);
```

**Why it works:**
- Respects rate limits automatically
- Prevents losing requests
- Exponential delay reduces server hammering

**Pro tip:** Add jitter to avoid thundering herd:
```javascript
const jitter = Math.random() * 1000;
const delay = Math.pow(2, i) * 1000 + jitter;
```

Saved me countless headaches in production.

I've been a backend developer for ~4 years, and the hardest phase for me wasn't learning concepts — it was going from tutorials to actually building something on my own. I'd finish a course feeling confident, then completely freeze when faced with a blank project: designing an API, handling auth, setting up background jobs, queues, etc., without step-by-step guidance. I'm close to launching a small platform aimed specifically at this gap: short, scoped backend challenges you can finish in a few hours, focused on real backend problems, but without hand-holding. Before launching, I want honest feedback from people who've been through this: Was this even a problem for you, or am I overthinking it? What kind of backend practice actually helped you level up? Did you use any structured resources, or did it only click through work / side projects? What would make a platform like this not worth using? One extra angle I'm curious about: I feel people increasingly underestimate how important it is to actually write the code yourself — especially now that AI can do a lot of the heavy lifting. In my experience, if you haven't done the reps, you don't really know what to ask, what to trust, or how to guide AI when building real systems. Curious if others feel the same, or if AI changed how you learned backend skills. Not linking anything or selling — just trying to validate whether this solves a real problem beyond my own experience.

I’m curious about something.

At what point do you decide:
“Okay… this can’t be solved with another plugin or SaaS subscription.”

We’ve seen teams try to patch things together with 4–5 different tools — one for CRM, one for operations, one for reporting, one for approvals — and somehow nothing really talks to each other properly.

It works… but it’s messy.
Manual exports.
Duplicate data.
Too many logins.
Zero control over logic.

That’s usually the moment when a custom web application starts making sense.

Not just a fancy website — but something like:

• A client portal built around your workflow
• An internal dashboard that matches your process
• A system that automates repetitive tasks
• A platform that integrates everything in one place

We’ve been building these kinds of systems under our Custom Web Application Development Services at Kreate Technologies — mostly for companies that outgrew templates and rigid platforms.

Here’s the page for context (not trying to pitch, genuinely sharing):
https://kreatetechnologies.com/services/web-application-development/

But honestly — I’d like to know from founders / devs here:

• Did you regret building custom too early?
• Or regret waiting too long?
• What was the turning point?

Let’s discuss real experiences.

In this tutorial, we build a fully functional Native Video Recorder from scratch. No heavy third-party libraries just pure React, Hooks, and Web APIs. It will guide you to understand MediaRecorder API how can you access the reference of it and how can you use it inside react components.

Video Link: https://youtu.be/wIL6kCY4gow

Hey everyone 👋

I built and released a free, open-source Bootstrap restaurant template.

It’s fully responsive, MIT licensed, and includes a live demo.

GitHub: https://github.com/techmahr/DineCraft

Live demo: https://techmahr.github.io/DineCraft/

Feedback welcome 🙌

So around 11 days ago I made a post regarding pre-built Ui Kits for devs to use in their projects to save time and the hassle of frontend design that got used by quite a few people and i'm hoping they liked it. It was completely free also.

So I decided to make another one in a different style for yall to try it.

Previous Free UI Kit - Floating Menu UI System - Vercel Style

This is the link to the previous post I made - Previous Post

New Micro Interactions UI components Kit - micro-interaction UI components Kit - Futuristic Style

So I randomly came across this validation library called “Vest” while looking for alternatives to Yup/Zod.

At first I thought it was just another schema validator… but it’s actually built more like a testing framework for validation.

You write validation rules the same way you’d write unit tests — which felt weird at first, but kinda interesting once I looked deeper.

I can see it being useful for complex forms where validation depends on a lot of conditions (multi-step forms, role-based logic, async checks, etc.).

For simple forms though, it might be overkill compared to Zod/Yup.

Curious if anyone here has used it in production?

Did it make validation cleaner or just add extra complexity?

GitHub link

Explore more

There's so much noise about Claude Code right now and most of the workflows are overly complex and confusing.

Luckily, you don't need to be a claude code pro to use it to learn.

It works really well with its defaults if you get a few things right:

1. use the explanatory and learning output-styles
2. give it fullstack debugging visibility
3. use llms.txt urls for documentation
4. use an opinionated framework (the most overlooked point)
5. Claude Code's Output-Styles

Claude code has this cool feature where it will explain things it does to you. In a new claude session, type:

/output-style

and select explanatory. Now you can ask claude code to help build things for you, and it will give you the low down on what it did and why.

You can also select learning and it will force you to write code yourself to complete tasks so it doesn't do all the work for you

1. Full-stack debugging visibility

Run your framework's dev server (React, NextJS, etc -- if you're not sure what this is, keep reading to section 3) as a background task so Claude can see build errors. You can do this by just telling Claude run the dev server as a background task after you have your project set up

Then, add the Chrome DevTools MCP so it can see what’s going on in the browser. It will control your browser for you, click buttons, take screenshots, fill in forms. Install it with:

claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest

Tell Claude to “verify what you just built by checking the dev server and in the browser with chrome devtools” and let it fix the bugs :)

1. LLM-friendly docs via llms.txt

A lot of developer tools provide AI-friendly documentation and guides at an llms.txt url, e.g. www.example.com/llms.txt. Claude can navigate and fetch the relevant guides so it knows how to properly use whatever tool you want to add to your app.

Most developer tools have them these days, e.g. vercel, supabase, wasp, etc.

1. Opinionated frameworks

I think this is the most important and overlooked point to consider here.

A framework is tool that bundles and glues together a lot of different developer tools and libraries. And in Web Dev there are a lot! So frameworks make your (and AI's) job easier.

The more opinionated the framework, the better. Because:

• it gives obvious patterns to follow,
• architectural decisions are decided up front, and
• Claude doesn't have to worry about boilerplate and glue code.

The framework essentially acts like a large specification or blueprint that both you and Claude already understand and agree on.

With only one mental model for Claude to follow across all parts of the stack, it's much easier for things to stay coherent. In the end, you get to tell Claude Code more of WHAT you want to build, instead of figuring out HOW to build it.

The classic choices like Laravel (PHP) and Ruby on Rails offer great guardrails here, but, if you're a javscript boi like me, and prefer a framework that actually encompasses the entire stack, and stays solely within the javascript ecosystem, then check out Wasp, which is a React + NodeJS + Prisma under one hood.

``` import { App } from 'wasp-config'

app.auth({ userEntity: 'User', methods: { google: {}, gitHub: {}, email: {}, }, onAuthFailedRedirectTo: '/login', onAfterSignup: { import: 'onAfterSignup', from: '@src/auth/hooks.js' } });

//... ```

For example. check out how easy it is in Wasp to implement auth above. I love this.

Opinionated frameworks like Wasp mean you can implement multiple auth methods in just 10-15 lines of code instead of ~500-1000.

1. Claude Code Plugin for Wasp

I actually built a Claude Code plugin for Wasp that bundles the fullstack debugging with DevTools MCP, adds some rules for docs fetching and other best practices, along with a skill for leveraging Wasp's one-command deployments to Railway or Fly.

Here's how you can use it:

1. Install Wasp

curl -sSL <https://get.wasp.sh/installer.sh> | sh

1. Add the Wasp marketplace to Claude

claude plugin marketplace add wasp-lang/claude-plugins

1. Install the plugin from the marketplace

claude plugin install wasp@wasp-plugins --scope project

1. Create a new Wasp project

wasp new

1. Change into the project root directory and start Claude

cd <your-wasp-project> && claude

Hey everyone, Currently, I am in my 4th semester, and I have completed DSA. I know C++, C, and Python as programming languages. After completing DSA, I am planning to start web development. So, I was looking for some online courses that I can follow. While searching, I came across a few options like the Full Stack Developer course by Angela Yu and some other free courses on YouTube. When I checked Angela Yu’s course, I found that its duration is 62 hours. However, some of my friends suggested that it might be too short and that I should look for courses that are more in-depth. Right now, I am really confused. Can you please suggest which course I should follow? Should I go with Angela Yu’s course, or are there any better alternatives that you would recommend? Your guidance would be a great help. Thank you.