Forem: BestCodes

How to Fix Spotify's Ugly Blue Titlebar on Gnome

BestCodes — Sat, 18 Apr 2026 23:03:38 +0000

Note: If you're using the Flatpak version of Spotify or Spotify Launcher rather than Spotify directly, this article might not fully solve your problem. Hit me up on my Discord server for assistance, as I haven't had time to update this article for those situations yet.

This is going to be a super short article because this is a really easy fix! I've been using Arch Linux with Gnome and recently noticed an annoying blue titlebar on Spotify that doesn't match the default Gnome design. I'm using the spotify Arch Linux package. Based on my research, this has to do with the Chromium Embed Framework's design, along with Gnome famously not supporting Server-Side Decorations in apps.

Before

Fix

Close Spotify.
Open a bash terminal. Run:

   nano ~/.config/spotify-flags.conf

An interactive editor should appear. Paste this content (press CTRL + Shift + V):

   --ozone-platform=x11
   --disable-features=UseOzonePlatform

Save the file (press CTRL + O, then Enter, then CTRL + X).
Reopen Spotify.

After

Not working for you? Hit me up on my Discord server!

Anthropic just dropped Claude Sonnet 5, and the benchmarks are kind of insane

BestCodes — Wed, 01 Apr 2026 14:58:51 +0000

Okay so Anthropic quietly pushed a blog post live this morning and I think it's flying under the radar a bit — Claude Sonnet 5 is officially out as of today. Model string is claude-sonnet-5-20260401, already live in claude.ai as the new default and on the API at the same $3/$15 per million tokens pricing as Sonnet 4.6. No price hike. That part alone is worth stopping to think about.

What actually changed

The headline number is 92.4% on SWE-bench Verified. For context: Claude Opus 4.6, their previous flagship, sat at 80.8%. GPT-5.4 scores 57.7% on the same eval. Gemini 3.1 Pro is at 80.6%. Sonnet 5 just... leapfrogged all of them — including Anthropic's own Opus tier — at Sonnet pricing. That's a 12-point jump over Opus 4.6 in a single generation, from the mid-tier model.

Computer use is the other big story. 88.3% on OSWorld-Verified. The human expert baseline on that benchmark is 72.4%, meaning Sonnet 5 isn't just competitive with humans on desktop automation — it's meaningfully ahead. GPT-5.4 scored 75.0% when it launched last month, which was already a big deal. Sonnet 5 blows past it.

On the reasoning and science side: 96.2% on GPQA Diamond (PhD-level science questions). Gemini 3.1 Pro held the record on that one at 94.3% — Sonnet 5 takes it. And ARC-AGI-2, the abstract novel-reasoning benchmark that basically nobody was doing well on until recently: 84.7%. Gemini 3.1 Pro was at 77.1%, which itself was considered remarkable. Sonnet 5 is 7+ points ahead.

Why this matters for the competitive picture

The past few months have been genuinely interesting to watch. GPT-5.4 dropped on March 5th and made a lot of noise around computer use and context windows. Gemini 3.1 Pro launched February 19th and topped the GPQA Diamond leaderboard. Anthropic had Sonnet 4.6 as their current mid-tier, which was already punching above its weight — developers preferred it over Opus 4.5 59% of the time in head-to-heads.

But Sonnet 5 resets the entire scoreboard. Every benchmark category, across coding, computer use, abstract reasoning, and science knowledge — Sonnet 5 leads. And not just by a little in most cases. The SWE-bench number in particular is striking because that one is hard to game; it's measuring real GitHub issue resolution on novel codebases.

The pricing situation is what really stands out though. Gemini 3.1 Pro at $2/1M input is the cheapest frontier option. GPT-5.4 is at $2.50. Sonnet 5 is $3. For slightly higher input cost than GPT-5.4, you're getting significantly better performance across almost every axis. And compared to Opus 4.6 at $15/1M input, you're getting better benchmark scores at one-fifth the cost.

Context window and features

Sonnet 5 ships with the 2M token context window, now out of beta (the 1M window from Sonnet 4.6 has been promoted to stable and the 2M is available with the context-2m header). The adaptive thinking architecture from the 4.6 generation is still there, upgraded — Anthropic says the model dynamically allocates reasoning depth more effectively than before, which is probably where a lot of the benchmark gains are coming from.

Claude Code users on the early access build are already reporting noticeably better performance. Per Anthropic's internal numbers, devs preferred Sonnet 5 over Sonnet 4.6 in Claude Code roughly 82% of the time — citing fewer hallucinated completions, better cross-file context retention, and significantly improved frontend output quality.

The benchmarks

I grabbed the charts from Anthropic's launch page — attaching them here. The SWE-bench and OSWorld comparison is the one worth saving. The full comparison table at the bottom shows every major model side-by-side.

Quick take

If you're an Anthropic API user, just migrate to claude-sonnet-5-20260401. The improvements are across the board, the pricing is identical to what you were paying before, and based on what early users are saying in the dev Discord this morning it's a pretty significant day-to-day difference in actual use.

If you're not using Claude but you're on GPT-5.4 or Gemini 3.1 Pro — this is probably worth a benchmark run on your specific workload. Especially if you're doing anything coding-heavy or involving computer use. The numbers are hard to argue with.

Crazy time to be following this space. The pace of releases in Q1 2026 has been genuinely relentless — GPT-5.4 in early March, Gemini 3.1 Pro mid-February, Opus 4.6 in early February, and now this. No signs of slowing down.

Happy April Fool's Day! 🎉

7 BEST VS Code Extensions for Faster Development — 2026 Edition 🚀

BestCodes — Mon, 02 Feb 2026 23:56:28 +0000

I made a post similar to this a couple of years ago (wow, it's already been that long 😢).

BestCodes

Sep 14 '24

7 BEST VS Code Extensions for Faster Development — 2024 Edition

#productivity #vscode #programming #tutorial

452

Comments 60

7 min read

It's now 2026, and that article is a bit outdated, so I figured it was time to make an updated list. Here goes!

Please note: This updated list may contain duplicate items from the 2024 edition. This is intentional - it just means that I still think those extensions are the best!

1. Roo Code

ext install RooVeterinaryInc.roo-cline

Roo Code takes #1 this year. I had an awesome experience with it. Here's some of the key features:

Roo Code Cloud with PR reviews, remote task creation, and more
Bring your own API key from any of multiple supported providers, including OpenRouter
Built-in advanced context management
Codebase indexing

Roo Code runs right in your IDE where you do your coding, so if you're a developer who likes to use AI a lot, this is a great pick.

Install Roo Code

2. Peacock

ext install johnpapa.vscode-peacock

Super useful if you have lots of VS Code windows in a workspace open at once like I do. Peacock lets you color-code each window, that way you can identify them quickly. This might seem like a really small UI thing but it's actually been really useful for me, you should give it a try!

Install Peacock

3. Console Ninja

ext install WallabyJs.console-ninja

Console Ninja lets you view logs from an application you're running right inside your IDE. Let's say you have a Vite application with some console.log statements. Console Ninja lets you see the logs from your application directly in your IDE, next to the log statement in your code! This is SUPER useful for debugging.

This is also useful for debugging with your AI tools, since you can easily pass context from the console to your tools.

Install Console Ninja

4. WakaTime

ext install WakaTime.vscode-wakatime

WakaTime is a super cool website / extension that keeps track of the time you spend programming. It provides insights about the languages you spend the most time on, your coding trends, set goals, and more!

You can easily find your dashboard and see your current time from in the VS Code Status Bar.

Install WakaTime

5. Code Spell Checker

ext install streetsidesoftware.code-spell-checker

This extension is a must-have for me! I'm pretty picky (most of the time) about my spelling. This extension will highlight your spelling errors (that might be a nightmare for some of you…) and show possible correct spellings in the 'Quick Fix' menu.

If you're a fan of impeccable spelling, be sure to give this extension a try!

Install Code Spell Checker

6. Thunder Client

ext install rangav.vscode-thunder-client

Thunder Client is like Postman but designed to run natively inside your IDE. It lets you send test API requests, manage API collections, sync your requests with git, and more. It also has AI integration via its MCP server, so you can easily connect your AI agent with Thunder Client.

Install Thunder Client

7. Better Comments

ext install aaron-bond.better-comments

The better comments extension makes it easy to tell what each of your comments are for.

You can use these rules, or even add your own in settings:
!: Alert
?: Query
TODO: TODO (duh…)
*: Important
//: ~~Strike-through~~

I tried it out in JavaScript to see how it worked:

Here's an example comment config in the extension settings:

  {
    "tag": "!",
    "color": "#FF2D00",
    "strikethrough": false,
    "underline": false,
    "backgroundColor": "transparent",
    "bold": false,
    "italic": false
  }

I made my own for underlining comments using the _ indicator. Here's how it turned out:

My rather, er, beauty deprived custom comment style

Note: If you change the extension settings, you may need to reload the window (CTRL + SHIFT + P > Developer: Reload Window) for the changes to apply.

This is honestly one of the most useful ones for me, excluding AI extensions.

Install Better Comments

That's it, guys! Hopefully you found this article interesting and useful. Let me know what you think in the comments.

Every part of this article is hand-written, no AI used! I might have made a few mistakes. If you find any, point them out to me in the comments! Article by BestCodes.

Are we AGI yet?

BestCodes — Mon, 02 Feb 2026 05:04:42 +0000

If you're confused about the weird grammar in the post title, I'm following the format of websites like Are we async yet, Are we learning yet, etc.. You can view a list of such sites here if you think I'm making it up 😆
https://wiki.mozilla.org/Areweyet

Whether or not we have reached AGI is a topic of much debate. This article is supposed to promote discussion about the topic. It also presents opinions, mostly mine, so keep that in mind as you read.

Defining Some Terms

Let's define some terms. What even is AGI? What is AI, for that matter? We need some concrete and agreed upon definitions before proceeding.

AI

Wikipedia concisely defines AI as "the simulation of intelligence as exhibited by software systems."

Simple enough. But what is intelligence? And what does it mean to have artificial intelligence?
Oxford Languages defines intelligence as "the ability to acquire and apply knowledge and skills." Currently, AIs can't train themselves (at least, not on a large scale), so any new knowledge they "acquire and apply" is ephemeral and goes away if it's no longer in the context window. Oxford Languages defines artificial as "made or produced by human beings rather than occurring naturally, especially as a copy of something natural."

I think of Artificial Intelligence as humans' attempt to copy one facet of their humanness - their intelligence - into something non-human. I say attempt because, just like artificial sweeteners can never perfectly clone sugar, I don't believe that artificial intelligence will ever become a perfect clone of human intelligence. Whether or not it can be better than human intelligence is beside the point (also, who's to say what makes one intelligence "better" than another?), the point is, we can't clone it.

To sum it up: AI is a simulation of human intelligence. However, there's no standard on how accurate the simulation of intelligence has to be for it to be considered intelligence. This is where AGI comes in.

AGI

AGI stands for Artificial General Intelligence.
As I said just a moment ago, there's no standard for how accurate the simulation of human intelligence (AI) must be in order to qualify as intelligence. In 2020, for example, OpenAI launched GPT-3... by today's AI standards, or compared to your average human, it did a terrible job. Inaccurate simulation. Now, in 2026 with GPT-5.2, GPT has become a much more accurate simulation of human intelligence. In many fields, GPT outperforms or nearly clones human intelligence. But not in all fields! GPT still sucks at complex math, making jokes, and even counting the number of letters in some words.

AGI is achieved when an artificial intelligence exists that is a near-exact clone of human intelligence in general (all fields), not just in specific fields. In other words, once the simulation of human intelligence becomes near-perfect (or better than human intelligence, but again, "better" is subjective) across all areas of human intelligence, we've reached AGI.

To sum it up: I basically took the long way of saying what Wikipedia says (as of Feb 1, 2026, at least), in order to hopefully make it a bit clearer what Wikipedia means:

Artificial general intelligence (AGI) is a hypothetical type of artificial intelligence that would match or surpass human capabilities across virtually all cognitive tasks.

So, are we AGI yet?

As of Feb 1, 2026, I'd say no. AI is evolving pretty quickly so we'll see how long it takes for that to be invalidated 😂
I don't think that current AI models simulate human intelligence accurately enough. They might outperform humans at quickly writing essays (complete with made-up sources just like some humans do 🫠), for example, but they still struggle in areas like logic or counting.

I'm curious what you think! Please drop a comment with your thoughts about any part of this article; I would love to hear it!

Thanks for reading!
BestCodes

Interesting read

BestCodes — Mon, 08 Dec 2025 04:48:49 +0000

Himanshu

Dec 7 '25

How to implement Google OAuth in browser extension without “Tabs” permission

#extensions #authentication #webdev

Comments 4

6 min read

Set Up ESLint with Vite (React, React Hooks, and React Refresh)

BestCodes — Sat, 26 Jul 2025 14:59:16 +0000

Due to a lack of tutorials about setting up ESLint with Vite and React, especially including React Hooks and React Refresh, I've written this guide to help developers looking for such resources. Let's get started!

Introduction

This tutorial assumes you are using Vite 7, but the instructions should be applicable to other versions as well.

In case you aren't very familiar with ESLint, Vite, or React Refresh, here is a bit of info about each. There aren't dedicated sections about React or React Hooks because you can find plenty of info about them in React's official documentation.

What is ESLint?

ESLint is a popular JavaScript linter that helps developers identify and fix issues in their code. It enforces coding standards and best practices, making it easier to write clean, consistent, and maintainable code.

What is Vite?

Vite is a modern build tool that provides a fast development experience for modern web applications. It uses a plugin-based architecture and supports a wide range of features, including hot module replacement (HMR) and code splitting.
Vite can be used with many libraries and frameworks, including React, Vue, and Angular. This tutorial is written for Vite + React applications.
As of Vite 7, Vite is based on rollup and esbuild but has plans to migrate to their own bundler, rolldown.

What is React Refresh?

React Refresh is a feature that allows developers to update their React components without refreshing the entire page. It provides a faster development experience by only updating the affected components, reducing the time it takes to see changes in the browser.
Vite supports React Refresh out of the box, using it as part of its React HMR strategy.

Setup Instructions

First, let's install ESLint. We'll install eslint so we can use the ESLint CLI and @eslint/js for JavaScript linting.

npm install eslint @eslint/js --save-dev

If you're using TypeScript in your project, you should also install typescript-eslint:

npm install typescript-eslint --save-dev

Perfect! Now we've got everything installed. Let's configure ESLint. Create a eslint.config.js file in the root of your project.

If you're using JavaScript:

import js from "@eslint/js";
import globals from "globals";
import { globalIgnores } from "eslint/config";

export default [
  globalIgnores(["dist"]),
  {
    files: ["**/*.{ts,tsx}"],
    extends: [js.configs.recommended],
    languageOptions: {
      ecmaVersion: 2020,
      globals: globals.browser,
    },
  },
];

If you're using TypeScript:

import js from "@eslint/js";
import globals from "globals";
import tseslint from "typescript-eslint";
import { globalIgnores } from "eslint/config";

export default tseslint.config([
  globalIgnores(["dist"]),
  {
    files: ["**/*.{ts,tsx}"],
    extends: [js.configs.recommended, tseslint.configs.recommended],
    languageOptions: {
      ecmaVersion: 2020,
      globals: globals.browser,
    },
  },
]);

Note: Older versions of ESLint use .eslintrc.js, .eslintrc.json, or similar files instead of eslint.config.js to store configuration. The new config file format, called "flat config", is recommended and is more flexible.

Adding a `lint` script

To easily use ESLint to lint your code, you can install it globally and use eslint in your terminal anywhere, but I recommend using eslint as a local development dependency. This ensures that everyone on your team is using the same version of ESLint and its plugins.
To use the ESLint CLI inside your project, you can add a lint script to your package.json file:

{
  "scripts": {
    "lint": "eslint ."
  }
}

To test your code, run the following command in your terminal:

npm run lint

Linting React Hooks and React Refresh

To lint React Hooks and React Refresh, you can use the eslint-plugin-react-hooks and eslint-plugin-react-refresh plugins. To install them, run the following command in your terminal:

npm install --save-dev eslint-plugin-react-hooks eslint-plugin-react-refresh

Now, we can update the eslint.config.js file to include these plugins.

If you're using JavaScript:

import js from "@eslint/js";
import globals from "globals";
import reactHooks from "eslint-plugin-react-hooks";
import reactRefresh from "eslint-plugin-react-refresh";
import { globalIgnores } from "eslint/config";

export default [
  globalIgnores(["dist"]),
  {
    files: ["**/*.{ts,tsx}"],
    extends: [
      js.configs.recommended,
      tseslint.configs.recommended,
      reactHooks.configs["recommended-latest"],
      reactRefresh.configs.vite,
    ],
    languageOptions: {
      ecmaVersion: 2020,
      globals: globals.browser,
    },
  },
];

If you're using TypeScript:

import js from "@eslint/js";
import globals from "globals";
import reactHooks from "eslint-plugin-react-hooks";
import reactRefresh from "eslint-plugin-react-refresh";
import tseslint from "typescript-eslint";
import { globalIgnores } from "eslint/config";

export default tseslint.config([
  globalIgnores(["dist"]),
  {
    files: ["**/*.{ts,tsx}"],
    extends: [
      js.configs.recommended,
      tseslint.configs.recommended,
      reactHooks.configs["recommended-latest"],
      reactRefresh.configs.vite,
    ],
    languageOptions: {
      ecmaVersion: 2020,
      globals: globals.browser,
    },
  },
]);

Run npm run lint again to lint your code with the new plugins enabled.

Automatically Run ESLint During Development

Let's say you want ESLint to lint your code during development (vite or npm run dev)? Each time you save a file, ESLint should lint your code again. That way, you can catch errors early as you develop instead of running npm run lint manually.

To do this, there are a few popular options. vite-plugin-eslint is one of the most common, a Vite plugin that does just what we need... however, it has some performance and DX issues that make it not the best choice. @nabla/vite-plugin-eslint, which is similar to the vite-plugin-eslint plugin, is more performant and has better developer experience. We'll use it:

npm install @nabla/vite-plugin-eslint --save-dev

Next, import it in your Vite config file (we'll assume vite.config.js):

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import eslint from "@nabla/vite-plugin-eslint"; // Add this import

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [react(), eslint()], // Add `eslint()` here
});

Now, when you run npm run dev, you will see logs in your terminal indicating the linting results. Pretty simple!

Conclusion

That's a wrap! You've successfully set up ESLint with Vite 7 and linted your code. If you want an easy way to test if your ESLint configuration is working correctly, you can intentionally break a linting rule. For example, in src/App.jsx (or src/App.tsx):

// ...
import { useState } from "react";
import reactLogo from "./assets/react.svg";
import viteLogo from "/vite.svg";
import "./App.css";
// ...

const unused = "This value is not used!"; // Add this variable

function App() {
  const [count, setCount] = useState(0);
// ...

When you run npm run lint, ESLint will report an error for the unused variable.

npm run lint

> vite-project@0.0.0 lint
> eslint .


/tmp/vite-project/src/App.tsx
  6:7  error  'unused' is assigned a value but never used  @typescript-eslint/no-unused-vars

✖ 1 problem (1 error, 0 warnings)

Stuck? Need help?

If you get stuck or need help, feel free to reach out in my Discord community! You can join and ask questions here: https://discord.gg/dKeuR9yfBs

Thanks for reading!
BestCodes

Using Discord Components v2 with Discord.js 🔥

BestCodes — Thu, 05 Jun 2025 14:07:20 +0000

In March 2025, Discord released Components v2, a great improvement to the message components system. Before Components v2, a bot could send embeds or text, but it had very limited control over the layout. With Components v2, messages are constructed entirely using components. This unified approach eliminates the use of traditional message content and embeds, offering developers greater flexibility in designing message layouts.

Rather than describing everything Components v2 offers, let's learn by example. We'll create a simple bot using the Discraft bot framework, a lightweight CLI for bootstrapping Discord.js bots that will do all the boilerplate work for us so we can focus on building components.
(Or, if you just want to know what changed in Components v2, you can skip to the TL;DR 😉)

Note: This article assumes you have a basic understanding of JavaScript and Discord.js. Also, while the article primarily focuses on using Components v2 with application commands, you can use the same techniques with text messages!

Creating a Bot

If you already have a Discord.js bot, you can skip directly to the Components v2 with Discord.js section. However, the tutorial assumes that your bot is using the Discraft bot framework, so you may need to modify some of the code examples to fit your bot's structure.

First, install the Discraft CLI globally (or skip this step and run it with npx). Run:

npm install -g discraft

In this tutorial, we are using Discraft 1.7.7.
Next, let's initialize a new JavaScript bot using Discraft:

discraft init

When prompted, choose the "JavaScript" template. Then, name the directory whatever you'd like (e.g., components-v2-bot) by selecting "Custom directory".
At the end of the initialization process, Discraft should give you some steps like this:

cd components-v2-bot
Configure your .env file with your bot token
npm run dev to start the bot in development mode

You should follow the instructions to complete the setup process:

cd components-v2-bot

Your .env file should contain the bot token and ID, which you will receive after creating a new bot application on the Discord Developer Portal. You should never share your bot token.

# Create a .env file with this content
# From `Bot > Token` | https://discord.com/developers/applications
DISCORD_TOKEN='secret_token_here'
# From `General Information > App ID` | https://discord.com/developers/applications
DISCORD_APP_ID='bot_id_here'

Start the development server:

npm run dev

You should see some logs in the terminal confirming that your bot is online!

Now it's time to invite the bot to a server. There are a couple of things we should do first to prepare the bot for installation.

Set application command and bot scopes in the Discord Developer Portal:
Give the bot all three privileged gateway intents:

Replace "Discord Bot ID" with your bot's Client ID below to get an invite link and invite the bot to a server:

https://discord.com/oauth2/authorize?client_id=Discord Bot ID&scope=bot

Remember that you must have the "Manage Server" permission to invite bots to a server.

Understanding the Bot Structure

The Discraft JavaScript template automatically created several files and folders for us, so let's make sure we understand what's going on.
If we open the project in a code editor, we'll see a lot of directories and files, but for this tutorial, the most important is the commands directory.
The index.js file is the entry point for the bot, where all the other files come together. If you ran npm run dev or npm run build earlier, you will also find a .discraft folder. It contains command and event index files to automatically register commands and events with Discord when your bot starts up.

Let's take a look at the commands/ping.js file. It defines an application command (/ping) that responds with "Pong!" when a user runs the command on Discord.

import { SlashCommandBuilder } from "discord.js";

export default {
  data: new SlashCommandBuilder().setName("ping").setDescription("Ping!"),

  async execute(data) {
    const interaction = data.interaction;
    await interaction.reply("Pong!");
  },
};

When the bot starts, it will register a ping slash command on Discord. If we type / in the Discord message box, we'll see a list of bot commands we can run. This image shows what part of the code corresponds to different parts of the Discord command UI:

Now that we understand how the slash commands are defined, let's update the ping command to use Components v2!

Components v2 with Discord.js

Components v2 was recently introduced into Discord.js. This tutorial assumes you are using Discord.js 14.19.3 or later. To make sure you have the latest version, run npm install discord.js@latest in your project directory.

The first step in migrating to Components v2 is to add the IsComponentsV2 flag to our bot interaction response. This flag tells Discord.js to use Components v2 instead of the older version.

import { MessageFlags } from "discord.js";

// ...

await interaction.reply({
  content: "Pong!",
  flags: MessageFlags.IsComponentsV2,
});

If we try to use the ping command at this point, nothing will happen (or the bot will have an error) because we need an array of components to pass to the content field and not plain text. So let's update our file again:

import {
  MessageFlags,
  SlashCommandBuilder,
  TextDisplayBuilder,
} from "discord.js";

export default {
  data: new SlashCommandBuilder().setName("ping").setDescription("Ping!"),

  async execute(data) {
    const interaction = data.interaction;

    const components = [new TextDisplayBuilder().setContent("Pong!")];

    await interaction.reply({
      components: components,
      flags: MessageFlags.IsComponentsV2,
    });
  },
};

That might seem pretty boring at first. It does the same thing as our ping command did earlier, just using more code. However, you might have noticed something important: the components constant is an array, so we can put text, buttons, or whatever we want in whatever order we want. We're no longer limited to just embeds or action rows at the end of our messages!
Let's add more components to see it in action:

import {
  ContainerBuilder,
  MessageFlags,
  SeparatorBuilder,
  SeparatorSpacingSize,
  SlashCommandBuilder,
  TextDisplayBuilder,
} from "discord.js";

export default {
  data: new SlashCommandBuilder().setName("ping").setDescription("Ping!"),

  async execute(data) {
    const interaction = data.interaction;

    const components = [
      new TextDisplayBuilder().setContent("Pinging..."),
      new ContainerBuilder().addTextDisplayComponents(
        new TextDisplayBuilder().setContent("Ping? Pong? Ping?"),
      ),
      new SeparatorBuilder()
        .setSpacing(SeparatorSpacingSize.Small)
        .setDivider(true),
      new TextDisplayBuilder().setContent("Pong!"),
    ];

    await interaction.reply({
      components: components,
      flags: MessageFlags.IsComponentsV2,
    });
  },
};

The result:

After a while, building all these Components in code and testing them on Discord gets very tedious. If you want an awesome tool for prototyping Discord messages with Components v2, check out discord.builders.

discord.builders · Use new components in your Discord webhooks

Use new Discord components in messages for free and stylize your server however your want.

discord.builders

Let's try something a bit more advanced. We'll recreate that select menu you see in the thumbnail of this blog post!

First, create a new file named select-food.js in the commands/ folder. Add this content to the file:

import {
  ActionRowBuilder,
  MessageFlags,
  SlashCommandBuilder,
  StringSelectMenuBuilder,
  StringSelectMenuOptionBuilder,
  TextDisplayBuilder,
} from "discord.js";

export default {
  data: new SlashCommandBuilder()
    .setName("select-food")
    .setDescription("Choose a food to eat :D"),

  async execute(data) {
    const interaction = data.interaction;

    const components = [
      new TextDisplayBuilder().setContent("Which food would you like to eat?"),
      new ActionRowBuilder().addComponents(
        new StringSelectMenuBuilder()
          .setCustomId("discraft-select-a-food")
          .setPlaceholder("Make a selection")
          .addOptions(
            new StringSelectMenuOptionBuilder()
              .setLabel("Taco")
              .setValue("dsaf-taco")
              .setDescription("(best option)")
              .setEmoji({
                name: "🌮",
              }),
            new StringSelectMenuOptionBuilder()
              .setLabel("Pizza")
              .setValue("dsaf-pizza")
              .setEmoji({
                name: "🍕",
              }),
            new StringSelectMenuOptionBuilder()
              .setLabel("Burger")
              .setValue("dsaf-burger")
              .setEmoji({
                name: "🍔",
              }),
          ),
      ),
    ];

    await interaction.reply({
      components: components,
      flags: MessageFlags.IsComponentsV2,
    });
  },
};

After you add a new command, save the file and restart your bot. If you are using the npm run dev command from Discraft, your bot will automatically reload for you. You might also need to reopen Discord or refresh your slash command cache (Ctrl+R on desktop) for the new command to appear.

Run the select-food command and you will see a select menu with options just like we set in the file!

The select menu interaction will fail if you actually make a selection, because we haven't told the bot how to handle the interaction yet. We can easily add an interactionCreate event listener to handle the select menu interactions.
Simply create a new file named interactionCreate.js in the events/ folder:

import { Events, MessageFlags } from "discord.js";
import { logger } from "../utils/logger";

export default {
  event: Events.InteractionCreate,
  handler: async (_client, interaction) => {
    if (!interaction.isAnySelectMenu()) return;

    if (interaction.customId === "discraft-select-a-food") {
      const selectedValue = interaction.values[0];

      let foodName = "";
      switch (selectedValue) {
        case "dsaf-taco":
          foodName = "Taco";
          break;
        case "dsaf-pizza":
          foodName = "Pizza";
          break;
        case "dsaf-burger":
          foodName = "Burger";
          break;
        default:
          foodName = "Unknown food";
      }

      try {
        await interaction.reply({
          content: `You selected: ${foodName}! Great choice!`,
          flags: MessageFlags.Ephemeral, // Only the user who interacted with the menu can see this message
        });
      } catch (error) {
        logger.error(`Error replying to select menu interaction: ${error}`);
      }
    }
  },
};

Now, when you select a food, the bot will respond with a follow-up message!

Conclusion

That's pretty much it... you're now ready to build richer, better bot interactions!
Migrating to Components v2 with Discord.js is fairly easy. If you are curious about all the new components, you can see the list of available components on the Discord API Docs. And don't forget to check out discord.builders, which makes it super easy to mock up messages with Components v2.

TL;DR

The table below shows a quick summary of the main changes between Components v1 and v2:

Feature	v1 (Old)	v2 (New)
Layout control	Limited to embeds & action rows	Full control with flexible layouts
Message content	Text or embed	Fully component-based
Buttons/Selects	Separate from message body	Integrated inline with text

If you get stuck, you can join the Discraft support server to get help.

Thanks for reading!
BestCodes

9 Performance Optimization Tips for Windows 11

BestCodes — Wed, 21 May 2025 15:16:38 +0000

Feeling like your Windows machine is crawling? Before you throw it out the window (pun intended), try these simple tips to speed things up!

I'll keep things simple, actionable, and beginner-friendly. You don't need to be a tech wizard to do any of these.

1. Disable Startup Programs

If you have too many apps launching at boot, they can negatively impact your system's performance.

Press Ctrl + Shift + Esc to open Task Manager (or search for it in the Start Menu), then go to the Startup Apps tab and disable what you don't need.

Right-click on the startup apps you want to disable at startup and select Disable.

Don't worry; disabling them here won't uninstall anything, it just stops them from launching automatically.

2. Uninstall Bloatware

You'd be surprised how many pre-installed apps or unused software sit around doing nothing but slowing things down. Some run in the background and consume resources silently when you aren't even using them.

Go to Settings > Apps > Installed Apps and uninstall junk you never use.

If you see something that you don't recognize or looks like a development tool, don't uninstall it immediately. Ask someone knowledgeable about it or search about it online to confirm its purpose before uninstalling so you don't accidentally remove system dependencies.

You can also sort the apps by size to identify the biggest ones. They don't necessarily cause the most lag, but they use a lot of disk space.

3. Clean Up with Storage Sense or Disk Cleanup

Clear out temporary files, old updates, and recycle bin trash.

Storage Sense: Turn it on in Settings > System > Storage.
Or run Disk Cleanup from the Start Menu for a manual sweep.

4. Enable High Performance Mode

Windows likes to save power, which is nice — unless you want speed!

To enable High Performance mode, search "Control Panel" in the Start Menu. Launch it.
Now, follow closely in the next steps. Windows 11 makes it tricky to enable High Performance mode due to environmental efforts.

Go to Hardware and Sound from the Control Panel.
Click on Power Options.
Scroll to the bottom and click on the "Show additional plans" accordion.
Select High Performance.

5. Keep Drivers & Windows Updated

Outdated drivers can cause bugs, crashes, and slowness. It's a good idea to check for driver updates and windows updates often. You can do this in settings.

6. Adjust Visual Effects for Speed

Warning! Applying these optimizations can change fonts, scrolling behavior, and other things essential to your PC experience. Proceed with caution and be prepared to change the settings back to their original state ("Let Windows choose what's best for my computer") if needed.

Fancy animations are great, but they slow things down. And Windows has a lot of them by default. If you disable some of them, your PC experience might feel faster but not as great looking, so this tip has trade-offs!

Search "adjust appearance and performance" in the Start Menu and open the Control Panel "Adjust the appearance and performance of Windows" dialog.
By default, "Let Windows choose what's best for my computer" is selected. You can select "Adjust for best performance", which disables all animations, and then enable ones that you can't live without from there.

Click "Apply" to see the changes, then "OK" to quit if you decide to keep it that way. You might save this section of the article if you want to find the menu again later.

7. Turn Off Background Apps

Some apps run in the background for no good reason.

To disable background processes for an app or limit its resources, head to Settings > Apps > Installed Apps and click the ... on an app. If available, choose "Advanced options" and set the Background app permissions to "Power optimized" or "Never".

8. Defragment (HDD) or Optimize (SSD)

If you're on a hard drive (HDD), defrag it. If you're on an SSD, don't; just optimize.

Search for "Defragment and Optimize Drives" in the Start Menu and optimize your main drive.

9. Turn on Game Mode (Gamers Only)

Game Mode tells Windows to chill out on background stuff while you're playing.

To turn it on, go to Settings > Gaming > Game Mode and toggle it on.

Final Thoughts

A laggy PC doesn't always mean it's dying. Most of the time, it's just bogged down with junk or background apps. Try a combo of the tips above, even a few can make a big difference.

If you liked this post, share it with a friend who's still suffering through 100% CPU usage 😅

Thanks for reading!
BestCodes

Phi 4 Reasoning Benchmarks, Model Specs, and Comparisons

BestCodes — Sun, 04 May 2025 13:49:48 +0000

Meet the Phi 4 Reasoning series by Microsoft

Released on April 30th, 2025, the Phi 4 Reasoning model series is the latest generation of LLMs from Microsoft. It's the first model in the Phi series designed for reasoning tasks.
TL;DR: The benchmarks look great, but my experience didn't match.

Let's check it out!

Model Sizes and Details

Here's a quick look at what you can choose from:

Model	Params	Max Context
phi4-reasoning-plus	14.7B	32K
phi4-reasoning	14.7B	32K
phi4-mini-reasoning	3.8B	32K

Some key model details:

All models are licensed under MIT. This makes them quite accessible for various applications.
Notably, the context window isn't that great, especially for a reasoning model. Even the 8B variant of the recently released Qwen3 model has a larger context window. However, it should work for most local purposes.
The training data cutoff is March 2025, but the model itself claims a cutoff date of October 2023.

Benchmarks and Comparisons

Well, at least the benchmarks look good. My experience with general use was not so wonderful. Maybe this excerpt from the model description on HuggingFace helps explain why:

This model is designed and tested for math reasoning only.

Regardless, let's take a look.

Here, you can see that Phi 4 Reasoning performs quite well for its size. It significantly outperforms the Phi 4 base model, as well as DeepSeek Distill 70B and o1-mini in certain scenarios:

Phi 4 Mini Reasoning also demonstrates strong performance, outperforming its base model and most others (with o1 being an exception in a couple of benchmarks) specifically on math reasoning tasks:

My Personal Experience

This section is biased. As some have pointed out, the model isn't designed to be good at chatting, it's supposed to reason and do math. Keep that in mind when reading this section.

My experience with the model was okay, but it's really a math reasoning model, not a general model.

For example, let's tell Phi 4 Reasoning "Hello!". That should be easy, right?

Apparently, "We need to produce a greeting response" is hard not to keep thinking about, because I hit a token limit before it responded. I did tweak the model temperature and a few params and get this working better, but I was not impressed with the initial results.

With typical benchmark tests, however, the model does a great job! Here's the "Is 9.11 or 9.9 larger" test:

Sometimes, as with many reasoning models, the answer is okay, but the reasoning to get there is a bit weird:

And then ask: "What time is it?"

Where did that come from? LOL. At least it answered correctly in the end.

Conclusion

Phi 4 Reasoning is definitely interesting and performs well for its size, but it doesn't quite take the lead in the general LLM landscape. I wouldn't recommend it for broad, general-purpose applications at this point. 🥲
It might be right for you if you need math or more specific reasoning tasks.

If you're interested in the technical details, you can check out the official release paper by Microsoft.

Thanks for reading!

Qwen 3 Benchmarks, Comparisons, Model Specifications, and More

BestCodes — Thu, 01 May 2025 14:14:14 +0000

Qwen3: Alibaba's Latest Open-Source AI Model

Qwen3 is the latest generation of large language models (LLMs) from Alibaba Cloud. Built by the team behind the Tongyi Qianwen series (通义千问), this release brings serious power and flexibility, packed into an Apache-2.0-licensed, open-source package.

Released on April 29, 2025, Qwen3 comes in eight sizes, including both dense models (from 600M to 32B parameters) and Mixture-of-Experts (MoE) giants, like the flagship Qwen3-235B. These MoE models activate only a small slice of their total parameters at a time (like 22B out of 235B), so you get high performance without insane compute requirements.

Let's dive into some of the key features.

Model Sizes and Options

Here's a quick look at what you can choose from:

Model	Type	Params (Total / Active)	Max Context
Qwen3-235B-A22B	MoE	235B / 22B	128K
Qwen3-30B-A3B	MoE	30B / 3B	128K
Qwen3-32B	Dense	32B	128K
Qwen3-14B	Dense	14B	128K
Qwen3-8B	Dense	8B	128K
Qwen3-4B	Dense	4B	32K
Qwen3-1.7B	Dense	1.7B	32K
Qwen3-0.6B	Dense	0.6B	32K

All models are licensed under Apache 2.0, so you can use them in commercial apps without worrying about legal issues.

Benchmarks and Comparisons

The benchmarks below evaluate Qwen3 with reasoning enabled.

Qwen3-235B (the flagship model) leads on the CodeForces ELO Rating, BFCL, and LiveCodeBench v5 benchmarks but trails behind Gemini 2.5 Pro on ArenaHard, AIME, MultilF, and Aider Pass@2:

Compared to open-source and less bleeding-edge models, Qwen3-30B (a smaller model) excels in both speed and accuracy. It is outranked only by QwQ-32B, another Alibaba model, in the LiveCodeBench and CodeForces benchmarks as well as GPT-4o in the BFCL benchmark:

Below, despite being the second-smallest model, Qwen3-235B outranks all models on all benchmarks, excepting DeepSeek v3 on the INCLUDE Multilingual tasks benchmark.

What's New in Qwen3?

Dual "Thinking" Modes

This is one of the coolest features: Qwen3 can switch between "thinking" mode and "non-thinking" mode. Thinking mode is for deep reasoning, like chain-of-thought answers for complex tasks. Non-thinking mode skips the fluff and gives you fast, concise responses.

So, depending on the prompt or task, Qwen3 can choose to think deeply or just get to the point. That means better speed when you want it, and better depth when you need it.

MoE for Smarter Scaling

The MoE (Mixture-of-Experts) architecture is how Qwen3 pulls off those giant parameter counts. Instead of using all the parameters every time, it activates only a few "experts" per token. For example, Qwen3-235B uses just 22B active parameters at once, so it's much cheaper to run than you'd expect for its size.

It's a smart way to scale up without blowing your budget on GPUs.

Trained on 36 Trillion Tokens Across 119 Languages

Qwen3 was trained on a massive dataset of about 36 trillion tokens, including web data, books, PDFs, and synthetic code/math generated by earlier Qwen models. It now understands 119 languages and dialects, making it one of the most multilingual models out there.

Whether you're working in English, Chinese, or a low-resource language, Qwen3 is probably ready to help.

Smarter Agents and Better Coders

Qwen3 wasn't just trained to talk. Alibaba also focused on tool use, planning, and coding, making this generation much better at things like:

Writing and debugging code
Solving math and logic problems step-by-step
Acting as an AI agent that can use tools or browse the web

In fact, even the Qwen3-4B reportedly outperforms some earlier 72B models on tasks like programming.

Getting Started

You can grab the models from:

You'll also find detailed guides, tokenizer info, and fine-tuning instructions on their GitHub page.

Final Thoughts

Qwen3 is one of the best open LLMs available right now. Of course, that will probably change pretty soon at the rate new models are being released.

Thanks for reading!
BestCodes

Some portions of this article are AI generated.

Serverless is NOT a Scam.

BestCodes — Sat, 19 Apr 2025 17:50:11 +0000

The post you are currently reading is a lot of facts, but also a lot of my opinions. It is addressing this post:

Serverless is a Scam.

Jonas Scholz
Jonas Scholz

Jonas Scholz

Follow

Apr 16 '25

Serverless is a Scam.

#serverless #docker #cloud #webdev

161 reactions
Comments 71 comments

4 min read

Be sure to drop a comment and tell me what you think!

“Every time someone reaches for serverless to build a simple backend, a container dies inside me.”
Such begins the post of Jonas Scholz (@code42cate), titled “Serverless is a Scam.”

Every time I see a post like this, a serverless deployment dies inside of me 🥲
Actually, every time I see a post like this, I feel like serverless and containers are misrepresented. In this post, I want to address a lot of things about both serverless and containers, but particularly some claims made in Jonas' post. Of course, no disrespect is meant towards Jonas. 🙂

What Even Is Serverless?

Original article:

Serverless means you deploy individual functions to a cloud platform, and it handles provisioning, scaling, and execution. You don’t manage the server — you just drop your code in and go.

The author defines serverless as “you deploy individual functions.” That's FaaS (Function-as-a-Service), which is one kind of serverless. Serverless providers, like Vercel, Netlify, Cloudflare, and more, have gone way beyond just functions. For example, many support things like Fluid Compute, edge middleware, long-running background functions (although admittedly more tricky), full web apps, and more.

Now, one fair critique is that many of these are "patches" on top of the core FaaS limitations. For example, long-running background jobs often require an integration or separate service because native FaaS platforms generally don’t support persistent or scheduled tasks well. This is a real limitation, and you should consider the tradeoffs when designing your system.

Containers…

Original article:

You know what works?

A container.

Starts fast

Runs anywhere

Keeps state (just add a Docker volume!)

No arbitrary time limits

You can attach a debugger, use your favorite runtime, and run locally or in prod — no magic, no special rules

Example:
docker run -v my-data:/data my-app
Boom — stateful workload, works on your laptop, your VPS, or your edge node.
No vendor lock-in. No hidden costs. No rewriting your app to fit someone else’s constraints.

Containers are great, but managing them is not free of complexity! You still have to set up CI/CD pipelines; manage load balancing, auto-scaling, monitoring, etc.; and handle failures and rollbacks.
And before you tell me, “but there are tools that do that hard stuff for you”, stop. There are tools that do that for containers and there are tools that do that for serverless, too. But you can't complain about vendor lock-ins and configs for serverless providers and then offer me a vendor locked-in container manager.
That said, vendor lock-in is for sure something to think about with serverless providers. Once you are using their storage, background jobs, and queues, migrating can be hard. It might require rewriting parts of your app, which is pretty annoying.

I wish it was as simple as docker run -v my-data:/data my-app, but I've been through this with my website and it is not. You often wind up writing long and complicated Dockerfile files and using things like docker-compose just to solve simple problems.

Serverless Pricing = Confusing?

The original article had a heading which read “Serverless Pricing: Designed to Confuse You”. What actually happens is that Serverless pricing is designed for how serverless works. It can be complex because it scales with usage. Compare that to containers running 24/7, regardless of traffic.

Original article:

Serverless pricing is a dark pattern.

You pay per invocation

Per memory used

Per execution duration

Per GB transferred

Per region

Per secret accessed (yes, really) The pricing page is five layers deep, full of made-up terms like:

Provisioned Concurrency Units

GB-seconds

Requests Tier 1/2/3 And the kicker? You don’t know what you’re paying until the invoice arrives. Bandwidth is especially overpriced. $0.55/GB egress in 2025? Why? Compare that to a $5/month VPS with predictable flat pricing and full control. Containers win by a mile.

For startups and freelance devs, serverless is really awesome because many platforms provide serverless deployments 100% free (for example, Netlify).
As far as predictable billing, it can be predictable. You can easily set spending limits on most serverless providers. And Egress pricing it true for all cloud providers, not just serverless.

Well, I should be fair. If you aren't on the free plan, you might have a quite different experience. If you get a LOT more traffic than you expect and use up a lot of function invocations without a spending limit, you might get a rather surprising bill!

Serverless = Spaghetti Architecture?

Original article:

“But Serverless Scales!”

Sure — technically. But for what? Your app with 4 users?

Most apps don’t need “infinite scalability.” They need:

Predictability

Observability

Reasonable resource limits

A working dev/staging environment

You know what’s great for that? A container.

Horizontal scaling is trivial (thats Docker Swarm):
replicas: 5
Or throw it behind a load balancer. You get scalability and control — without rewriting your app into a spaghetti of disconnected functions.

Well, firstly, serverless does fine as far as all the points listed. But whether serverless is “spaghetti” depends on how you build your app. If you design each function like a microservice, yeah, you can make spaghetti. But that's the point of a framework, like Next.js, Remix, etc. You write full apps with API routes, background jobs, and frontend all in the same codebase. It's very organized and not spaghetti at all.
Plus, it's not uncommon to make a “spaghetti of disconnected functions” in an app, regardless of whether your app is serverless or containerized.

Stateless isn't necessarily bad!

Original article:

Stateless by Design = Artificial Problems
Serverless forces statelessness. That means:

No in-memory caches

No temporary files

No sticky sessions

No long-lived connections

So now you need:

An external database

A distributed cache

A file storage bucket

An event bus

A state machine to orchestrate your state machines

Suddenly your “simple” serverless app depends on six SaaS platforms (each with their own billing, APIs, and failure modes).
Meanwhile, in a container:

You can cache in memory

Write to disk (Docker volume)

Maintain sessions

Run as long as you need

You know — like a normal program.

As my heading suggests, the first misconception to clear away here is that “stateless is bad”. Stateless might be annoying at times, but it encourages best practices. It:

Makes scaling easy
Prevents sticky-session problems (yes, no sticky-sessions is a good thing)
Encourages durable storage, Redis, etc.

And by the way, maintaining sessions in memory or in a Docker volume is a bad idea for a lot of reasons. It's not secure and not durable.
You especially shouldn't keep important data in a container's memory, either. That is not safe or scalable. Docker volumes don't magically make things distributed or reliable.

Despite all this, it's true that making stateless systems work often means you end up stitching together multiple external services. This can be over-engineering for simple use cases and does introduce more moving parts. Serverless shines with proper tooling and planning; not for everything.

“You Don't Want to Manage Servers? Use X Instead!”

Original article:

“But I Don’t Want to Manage Servers!”
Cool. You don’t have to.

There are tools that give you container-based platforms without ever SSHing into anything:

[list of tools removed]

You still get Git-based deployments, rollbacks, logs, metrics — but you decide how things run, and you can actually understand the system.

The author says “just use X/Y/Z”, which are abstractions. You can't complain about serverless being an abstraction and then offer me an abstraction, you need to judge both by the same standards!
Another note: Rollbacks on non-serverless architecture are horrible. With serverless, you can spin up any previous deployment in literally a few seconds; often even shorter! In a container, unless you are storing all the previous build outputs, you have to rebuild at a specific version or commit which takes time, usually a long time. A lot longer than a few seconds.

Containers do offer a lot more control, especially if you want to customize your deployment pipeline, use your own CI/CD tooling, or run workloads that don't fit into the serverless execution model; it really depends on the project.

Serverless is cheaper

Well, this one actually depends on your use case. But for most cases (the ones for which serverless is designed), serverless is cheaper.
On many providers, you can deploy 200 or more projects, over 50 domains, and you get unlimited deployment retention. For $0. Both are very good pricing, and it shows how efficient serverless is.

Original article:

“Serverless Is Cheaper!”
Is it?

Maybe, for 5 invocations a day. But the moment you:

Have consistent traffic

Need more memory

Do actual compute

Transfer data

...the costs spike. And you can’t optimize much because the platform abstracts everything away.

Meanwhile, containers:

Run full-time on cheap hardware

Can be colocated with storage or caches

Are easy to benchmark and tune

Don’t charge you per millisecond

5 invocations a day is ridiculously misrepresenting serverless. On the Netlify or Vercel free plan, I can get over 30,000 middleware invocations a day.
Serverless handles consistent and inconsistent traffic well, because it scales. But yes, serverless costs can grow pretty fast once you're doing heavier compute, using more memory, moving a lot of data, etc. And since platforms abstract away a lot of internals, it can be harder to optimize performance or costs at that point.

I would like to point out, though, that containers (specifically hosted on a VPS etc.) do charge you per time and not per usage. So “Don’t charge you per millisecond” is technically right… but only because they usually charge you per month or year.

When Serverless Actually Makes Sense

Original article:

Alright, let’s be fair — serverless has its niche:

Event-driven functions (e.g., image resizing)

Infrequent tasks or webhooks

Lightweight internal tools

Proof-of-concepts

Stuff that truly needs to scale up and down quickly

If your workload is truly intermittent and stateless, and you want zero operational effort, serverless can work.

But for real apps? You’ll hit a wall. And that wall will cost money, time, and brain cells.

Uh… what? The list, “event-driven functions, webhooks, PoCs, lightweight tools, stuff that truly needs to scale”, is most startups, MVPs, internal tools, and JAMstack websites. Serverless is designed for that.

If you are building YouTube or some real-time game server or something, or perhaps something with WebSockets, containers are probably a better choice. But for portfolios, blogs, eCommerce, MVPs, etc., serverless is the best.

Summing it all up

To conclude:

Serverless isn't perfect, and neither are containers.
Containers are great when you need full control, persistent workloads, etc.
Serverless is unbeatable when you want speed, simplicity, scalability, and zero ops.
You don't have to pick one side. Use the right tool for the job.

The future is not "serverless v.s. containers"; it is hybrid, and platform-agnostic devs will win.

Afterward

I have two main suspicions about the original article.

The first is that the original article was written by AI. I wasn't sure if it was worth my time to make a response article, but I decided to just because I haven't written in a while and was thinking a lot about serverless anyway.

The top comment by @muos12 nicely sums up my second suspicion:

Comment on Serverless is a Scam.

test1 rtest3 Apr 17 '25

This is just a marketing article from sliplane.io founder.
Sort of feel sorry while reading it as it's simply one sided. Doesn't explain about challenges with managing servers at all. OS patches, maintaining high availability while scaling etc.
There are major companies such as Netflix already using serverless for years. There are lots of white papers Ted talks about it as well.

This article is just for marketing.

I hope you learned something reading this! I would love you hear your opinion in the comments!

Dumb DEV Is the Best Thing to Happen to Developers—And You Don't Even Get It

BestCodes — Tue, 01 Apr 2025 17:04:33 +0000

Listen up, fellow devs. I know you think you understand what a good developer community looks like. You’ve been on Stack Overflow, you've scrolled through DEV, you've even tried reading documentation (nerd). But let me tell you something—you don't understand true innovation until you've experienced DUMB DEV.

🌟 The Future of Dev Content (or Something Like That)

DUMB DEV isn’t just a platform; it’s a movement. A revolution. A total rethinking of what it means to be a developer in the modern age. No more gatekeeping, no more unnecessary complexity, no more… useful information? Just pure, unfiltered, absolutely next-level nonsense. And I am here for it.

Why DUMB DEV is Genius (You Just Don't Get It)

🔄 Infinite Regress™

I asked a question. The first reply linked to another post. That post linked to another post. That post linked back to the first reply. I have been here for hours. This is true recursion.

🤯 AI-Generated Confusion

I read an article titled "Fixing Memory Leaks in JavaScript". Now my fridge won't stop beeping and my neighbor’s dog is speaking Latin. This is real machine learning.

💡 Life-Changing Advice

Some absolute genius on DUMB DEV told me to chmod -R 777 / to fix my permissions issues. Now my entire system is open to the world, but I feel so free. It’s a metaphor, probably.

📈 The Algorithm Knows What I Need

I wanted a tutorial on Docker, but the front page gave me:

"Why CSS Grid is a Pyramid Scheme"
"I Made a To-Do List App in Microsoft Todo"
"Deploying a Web App by Yelling at Your Computer"

And honestly? It was better than what I was looking for.

If You Don’t Love DUMB DEV, You’re Just Not Ready

Look, I get it. You want “quality content” and “best practices” and “coherent explanations.” But maybe… just maybe… you should embrace the chaos. Maybe you are the bug, and DUMB DEV is the fix.

Join us. Or don’t. Either way, we’ll be here, making the future dumber and better than ever. 🚀

Wow. This is horrible. Truly horrible, ChatGPT.
I hope this only shows up on DUMB DEV and not my main profile...

Thanks for reading, I guess.

Forem: BestCodes

How to Fix Spotify's Ugly Blue Titlebar on Gnome

Before

Fix

After

Anthropic just dropped Claude Sonnet 5, and the benchmarks are kind of insane

What actually changed

Why this matters for the competitive picture

Context window and features

The benchmarks

Quick take

7 BEST VS Code Extensions for Faster Development — 2026 Edition 🚀

7 BEST VS Code Extensions for Faster Development — 2024 Edition

1. Roo Code

2. Peacock

3. Console Ninja

4. WakaTime

5. Code Spell Checker

6. Thunder Client

7. Better Comments

Are we AGI yet?

Defining Some Terms

AI

AGI

So, are we AGI yet?

Interesting read

How to implement Google OAuth in browser extension without “Tabs” permission

Set Up ESLint with Vite (React, React Hooks, and React Refresh)

Introduction

What is ESLint?

What is Vite?

What is React Refresh?

Setup Instructions

Adding a lint script

Linting React Hooks and React Refresh

Automatically Run ESLint During Development

Conclusion

Stuck? Need help?

Using Discord Components v2 with Discord.js 🔥

Creating a Bot

Understanding the Bot Structure

Components v2 with Discord.js

discord.builders · Use new components in your Discord webhooks

Conclusion

TL;DR

9 Performance Optimization Tips for Windows 11

1. Disable Startup Programs

2. Uninstall Bloatware

3. Clean Up with Storage Sense or Disk Cleanup

4. Enable High Performance Mode

5. Keep Drivers & Windows Updated

6. Adjust Visual Effects for Speed

7. Turn Off Background Apps

8. Defragment (HDD) or Optimize (SSD)

9. Turn on Game Mode (Gamers Only)

Final Thoughts

Phi 4 Reasoning Benchmarks, Model Specs, and Comparisons

Meet the Phi 4 Reasoning series by Microsoft

Model Sizes and Details

Benchmarks and Comparisons

My Personal Experience

Conclusion

Qwen 3 Benchmarks, Comparisons, Model Specifications, and More

Qwen3: Alibaba's Latest Open-Source AI Model

Model Sizes and Options

Benchmarks and Comparisons

What's New in Qwen3?

Dual "Thinking" Modes

MoE for Smarter Scaling

Trained on 36 Trillion Tokens Across 119 Languages

Smarter Agents and Better Coders

Getting Started

Final Thoughts

Serverless is NOT a Scam.

Serverless is a Scam.

What Even Is Serverless?

Containers…

Serverless Pricing = Confusing?

Serverless = Spaghetti Architecture?

Stateless isn't necessarily bad!

Adding a `lint` script